primocode 10.15.2 → 10.17.0

package/voz/primo_voz/conversa.py

@@ -6,7 +6,6 @@ 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"
 """
@@ -165,31 +164,6 @@ def resumo(texto: str, frases: int = 60, teto: int = 3000) -> Tuple[str, str]:
     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 = [

package/voz/primo_voz/hud.html

@@ -144,6 +144,10 @@
   .leg span::before { content:""; display:inline-block; width:8px; height:8px; border-radius:50%; margin-right:6px; background:var(--marca); }
   .leg span.p::before { background:var(--ok); }
   .tecla { font-size:12px; color:var(--fraco); white-space:nowrap; }
+  .voltar-chat { display:inline-flex; align-items:center; gap:8px; height:38px; padding:0 16px; border:1px solid var(--borda); border-radius:999px; background:var(--fundo); color:var(--texto); font:500 13px var(--sans); cursor:pointer; white-space:nowrap; transition:border-color .2s; }
+  .voltar-chat:hover { border-color:var(--marca); }
+  .voltar-chat kbd { font:11px var(--mono); color:var(--fraco); }
+  .voltar-chat[hidden] { display:none; }
 </style>
 </head>
 <body>
@@ -270,6 +274,7 @@
     <div id="barras"></div>
     <div class="leg"><span>você</span><span class="p" id="leg-nome">Primo</span></div>
     <div class="tecla">⌨ luz do teclado no ritmo da voz</div>
+    <button class="voltar-chat" id="b-chat" hidden onclick="post({acao:'chat'})">← Voltar pro chat <kbd>esc</kbd></button>
   </section>
 </main>
 
@@ -529,7 +534,7 @@ function classeTela() {
 function setEstado(e) {
   if (!e || e === S.estado) return;
   S.estado = e; classeTela(); $('nome').dataset.e = e;
-  $('estado-t').textContent = e === 'dormindo' ? 'diga "' + S.nome + '"' : (ROTULO[e] || e);
+  $('estado-t').textContent = e === 'dormindo' ? 'clique para falar' : (ROTULO[e] || e);
   R3.estado(e);
   S.olhar = (e === 'pensando' || e === 'executando') ? 1 : 0;
   $('eq').setAttribute('opacity', e === 'falando' ? 1 : 0);
@@ -557,8 +562,9 @@ function laco(t) { SP.quadro(t); if (!R3.ok && !SP.ok) animaEq(t); requestAnimat
 /* ── a ponte com o Python ── */
 window.primo = (m) => {
   if (m.pasta !== undefined) $('pasta').textContent = m.pasta;
+  if (m.comChat) $('b-chat').hidden = false;
   if (m.login !== undefined) $('b-entrar').hidden = !!m.login;
-  if (m.nome) { S.nome = m.nome; $('nome-h').textContent = m.nome; $('leg-nome').textContent = m.nome; if (S.estado === 'dormindo') $('estado-t').textContent = 'diga "' + m.nome + '"'; }
+  if (m.nome) { S.nome = m.nome; $('nome-h').textContent = m.nome; $('leg-nome').textContent = m.nome;  }
   if (m.robo === 'expressive' && !SP.ok) { if (SP.cancela) SP.cancela(); SP.falhou = true; classeTela(); }
   if (m.evento) R3.evento(m.evento);
   if (m.boot) montar();

package/voz/primo_voz/hud.py

@@ -30,8 +30,9 @@ 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."""
+def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=None, chat=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.
+    chat: o app.Chat; com ele a janela abre no chat.html e a voz (hud.html) fica atrás, trocada pelo botão de onda."""
     try:
         from AppKit import (NSApplication, NSApplicationActivationPolicyRegular, NSImage, NSMenu, NSMenuItem, NSBackingStoreBuffered, NSColor,
                             NSEvent, NSScreen, NSWindow)
@@ -56,6 +57,40 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
     def js(msg: dict) -> None:
         fila.put("window.primo(" + json.dumps(msg, ensure_ascii=False) + ")")
 
+    fila_chat: "queue.Queue[str]" = queue.Queue()
+    fila_ui: "queue.Queue" = queue.Queue()          # o que mexe na janela, rodado na thread principal
+
+    def js_chat(msg: dict) -> None:
+        fila_chat.put("window.chat&&window.chat(" + json.dumps(msg, ensure_ascii=False) + ")")
+
+    telas: dict = {}
+
+    def mostrar(qual: str) -> None:
+        """Troca entre o chat e a voz na mesma janela, sem recarregar nenhuma das duas."""
+        if not telas:
+            return
+        telas["chat"].setHidden_(qual != "chat")
+        telas["hud"].setHidden_(qual != "hud")
+        telas["atual"] = qual
+        telas["jan"].makeFirstResponder_(telas[qual])
+        if qual == "hud":
+            js({"comChat": True})
+            js({"boot": True})
+            if chat is not None:
+                threading.Thread(target=chat.app.ligar_voz, daemon=True).start()
+        elif chat is not None:                  # voltou pro chat: o microfone fecha
+            threading.Thread(target=chat.app.desligar_voz, daemon=True).start()
+
+    def painel_arquivos(pastas: bool):
+        from AppKit import NSOpenPanel
+        pn_ = NSOpenPanel.openPanel()
+        pn_.setCanChooseFiles_(not pastas)
+        pn_.setCanChooseDirectories_(pastas)
+        pn_.setAllowsMultipleSelection_(not pastas)
+        if pn_.runModal() != 1:
+            return []
+        return [str(u.path()) for u in pn_.URLs()]
+
     class Janela(NSWindow):
         def canBecomeKeyWindow(self):
             return True
@@ -73,6 +108,19 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
                     break
                 self.web.evaluateJavaScript_completionHandler_(cod, None)
                 n += 1
+            while telas:
+                try:
+                    cod = fila_chat.get_nowait()
+                except queue.Empty:
+                    break
+                telas["chat"].evaluateJavaScript_completionHandler_(cod, None)
+            while True:
+                try:
+                    fila_ui.get_nowait()()
+                except queue.Empty:
+                    break
+                except Exception as e:
+                    sys.stderr.write(f"hud: {e}\n")
             if self.jan.isMiniaturized():
                 return
             if p.visivel != bool(self.jan.isVisible()):
@@ -124,6 +172,8 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
                 sys.stderr.flush()
             elif a == "sair":
                 p.visivel = False
+            elif a == "chat":                   # "Voltar pro chat", na tela de voz
+                mostrar("chat")
             elif a in ("ptt", "entrar"):
                 emitir({"acao": a})
             elif a == "print":                  # esconde o HUD para o print pegar a tela de verdade
@@ -140,6 +190,52 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
                         js({"musica": td.musica()})
                 threading.Thread(target=_fazer, daemon=True).start()
 
+    class MsgChat(NSObject, protocols=[objc.protocolNamed("WKScriptMessageHandler")]):
+        """A ponte do chat.html. O que mexe na janela (trocar de tela, painel de arquivos, abrir link) é daqui; o resto vai para o app.Chat."""
+        def userContentController_didReceiveScriptMessage_(self, ucc, msg):
+            try:
+                m = json.loads(str(msg.body()))
+            except ValueError:
+                return
+            a = m.get("acao")
+            if a == "erro":
+                sys.stderr.write("chat.html: " + str(m.get("arg")) + "\n")
+                sys.stderr.flush()
+            elif a == "voz":                    # botão de onda: abre a voz e já começa a ouvir
+                mostrar("hud")
+                emitir({"acao": "ptt"})
+            elif a == "anexar":
+                caminhos = painel_arquivos(False)
+                if caminhos:
+                    threading.Thread(target=chat.anexar_caminhos, args=(caminhos,), daemon=True).start()
+            elif a == "escolher_pasta":
+                caminhos = painel_arquivos(True)
+                if caminhos:
+                    threading.Thread(target=chat.escolher_pasta, args=(caminhos[0],), daemon=True).start()
+            elif a == "abrir_link":
+                from AppKit import NSWorkspace
+                u = str(m.get("url") or "")
+                if u.startswith(("http://", "https://")):
+                    NSWorkspace.sharedWorkspace().openURL_(NSURL.URLWithString_(u))
+            elif a == "haptico":                # a travadinha do esforço: o trackpad dá um toque em cada nível
+                try:
+                    from AppKit import NSHapticFeedbackManager
+                    padrao = 2 if m.get("forte") else 1          # 1 = alinhamento (leve), 2 = troca de nível (mais firme)
+                    NSHapticFeedbackManager.defaultPerformer().performFeedbackPattern_performanceTime_(padrao, 1)
+                except Exception as e:
+                    sys.stderr.write(f"hud: háptico: {e}\n")
+            elif a in ("abrir_arquivo", "mostrar_finder"):     # só o que existe; o Mac abre com o app padrão
+                from AppKit import NSWorkspace
+                c = Path(os.path.expanduser(str(m.get("caminho") or "")))
+                if c.is_absolute() and c.exists():
+                    ws = NSWorkspace.sharedWorkspace()
+                    if a == "abrir_arquivo":
+                        ws.openURL_(NSURL.fileURLWithPath_(str(c)))
+                    else:
+                        ws.activateFileViewerSelectingURLs_([NSURL.fileURLWithPath_(str(c))])
+            else:
+                chat.receber(m)
+
     app = NSApplication.sharedApplication()
     app.setActivationPolicy_(NSApplicationActivationPolicyRegular)   # app de verdade: Dock e Cmd+Tab
     try:                                                              # nome e ícone do Primo, mesmo fora do bundle
@@ -185,21 +281,49 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
     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)))
+    if chat is None:
+        jan.setContentView_(web)
+    else:                                   # o chat na frente; a voz atrás, já carregada (troca sem esperar)
+        from AppKit import NSView
+        fundo = NSView.alloc().initWithFrame_(NSMakeRect(0, 0, tela.size.width, tela.size.height))
+        fundo.setAutoresizingMask_(2 | 16)
+        cfg_c = WKWebViewConfiguration.alloc().init()
+        cfg_c.preferences().setValue_forKey_(True, "allowFileAccessFromFileURLs")     # o vídeo/imagem/PDF citados tocam ali mesmo
+        cfg_c.userContentController().addScriptMessageHandler_name_(MsgChat.alloc().init(), "chat")
+        web_c = WKWebView.alloc().initWithFrame_configuration_(NSMakeRect(0, 0, tela.size.width, tela.size.height), cfg_c)
+        web_c.setAutoresizingMask_(2 | 16)
+        web_c.setValue_forKey_(False, "drawsBackground")
+        # leitura da pasta pessoal: os arquivos que o agente cita (~/Primo/…) aparecem no chat sem servidor
+        web_c.loadFileURL_allowingReadAccessToURL_(NSURL.fileURLWithPath_(str(AQUI / "chat.html")), NSURL.fileURLWithPath_(str(Path.home())))
+        fundo.addSubview_(web)
+        fundo.addSubview_(web_c)
+        jan.setContentView_(fundo)
+        telas.update({"chat": web_c, "hud": web, "jan": jan, "atual": "chat"})
+        web.setHidden_(True)
+        chat.js = js_chat
+        chat.mostrar_voz = lambda: fila_ui.put(lambda: mostrar("hud"))    # um pedido falado com o chat na frente
     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()
+    if chat is None:                        # sem chat a voz é a tela: o robô acorda com o som
+        threading.Timer(1.2, lambda: (js({"nome": identidade.ler()["nome"]}), js({"robo": identidade.ler()["robo"]}), js({"boot": True}), sons.tocar("boot"))).start()
+    else:                                   # com chat: só o nome e o robô, em silêncio; o boot fica pra quando abrir a voz
+        threading.Timer(1.2, lambda: (js({"nome": identidade.ler()["nome"]}), js({"robo": identidade.ler()["robo"]}))).start()
 
     def esconder():
         p.visivel = False
 
     def tecla(ev):
-        if ev.keyCode() == 53:                    # ESC
+        if ev.keyCode() == 53:                    # ESC: na voz com chat, volta pro chat; no chat, fica com a página
+            if telas:
+                if telas["atual"] == "hud":
+                    mostrar("chat")
+                    return None
+                return ev
             esconder()
             return None
         return ev

package/voz/primo_voz/identidade.py

@@ -1,7 +1,7 @@
 """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
+Luna", ou `primocode voz nome Luna`). O nome NÃO ativa nada: o modo voz só abre no clique. 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

package/voz/primo_voz/painel_dados.py

@@ -0,0 +1,134 @@
+"""painel_dados.py — os dados do painel (música, calendário, clima, máquina) como um processo à parte.
+
+No Mac, quem alimenta o hud.html é o processo da janela (hud.py: as threads `medir()` e `agenda()`). O app desktop (Electron)
+não tem esse processo, então este ajudante roda os MESMOS laços e escreve cada mensagem como uma linha de JSON no stdout:
+o mesmo objeto que o `js(...)` do hud.py manda pra tela (`{"musica":...}`, `{"calendario":...}`, `{"hoje":...}`, `{"clima":...}`,
+`{"maquina":...}`). O app repassa cada linha pra `window.primo(msg)`. O hud.py não muda.
+
+    sai (stdout):   uma mensagem do painel por linha (e, ao iniciar, {"nome":..} e {"robo":..} da identidade)
+    entra (stdin):  ações da tela, uma por linha: {"acao":"midia","arg":"proxima"}, {"acao":"calendario"},
+                    {"acao":"volume",...}, {"acao":"app",...}, {"acao":"boot"} (toca o som de abertura)
+    fecha o stdin:  o ajudante encerra.
+Rode com:  python -m primo_voz.painel_dados
+"""
+from __future__ import annotations
+
+import json
+import sys
+import threading
+import time
+
+from primo_voz import identidade, tela as td
+from primo_voz import painel as pn
+from primo_voz.sons import Sons
+
+# Ações da janela (o app cuida delas): o ajudante ignora.
+DA_JANELA = {"erro", "sair", "chat", "ptt", "entrar", "print"}
+
+
+def main(entrada=None, saida=None, td_=None, pn_=None, sons=None, passo: float = 1.0) -> int:
+    """entrada/saida/td_/pn_/sons/passo: o teste troca por falsos e acelera os laços. `passo` = segundos do laço da máquina (o resto é múltiplo dele)."""
+    td_ = td_ or td
+    pn_ = pn_ or pn
+    entrada = sys.stdin if entrada is None else entrada
+    escrever = saida or sys.stdout
+    trava = threading.Lock()
+    parar = threading.Event()
+    sons = sons if sons is not None else Sons(True)
+
+    def js(msg: dict) -> None:
+        with trava:
+            try:
+                escrever.write(json.dumps(msg, ensure_ascii=False) + "\n")
+                escrever.flush()
+            except Exception:
+                parar.set()                 # o app fechou o cano: acabou
+
+    def espera(s: float) -> None:
+        parar.wait(s)
+
+    def medir() -> None:
+        am = pn_.Amostrador()
+        cache: dict = {}
+        k = 0
+        while not parar.is_set():
+            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"painel_dados: {e}\n")
+            k += 1
+            espera(passo)
+
+    def agenda() -> None:           # em outra thread: o pedido de permissão do Calendário pode demorar
+        evs: dict = {"permissao": "pendente", "eventos": []}
+        k = 0
+        falhas = 0
+        while not parar.is_set():
+            try:
+                if k % 12 == 0 or evs["permissao"] != "ok":     # sem acesso, olha a cada 5 s (a pessoa pode ter liberado)
+                    novo = td_.eventos_do_mes()
+                    if evs["permissao"] == "ok" and novo["permissao"] != "ok":
+                        falhas += 1                              # erro transitório não derruba o cartão: segura os últimos eventos
+                        if falhas >= 4:
+                            evs, falhas = novo, 0
+                    else:
+                        evs, falhas = novo, 0
+                # SEMPRE manda o estado junto: o painel nunca depende de uma mensagem que pode ter chegado antes da página
+                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"painel_dados agenda: {e}\n")
+            k += 1
+            espera(5 * passo)
+
+    def acao(m: dict) -> None:
+        try:
+            _acao(m)
+        except Exception as e:                  # uma ação que estoura não derruba o ajudante
+            sys.stderr.write(f"painel_dados: ação {m.get('acao')}: {e}\n")
+
+    def _acao(m: dict) -> None:
+        a = m.get("acao")
+        if a in DA_JANELA:
+            return
+        if a == "boot":
+            sons.tocar("boot")
+        elif td_.acao(m):
+            pass
+        else:
+            pn_.executar_acao(m)
+            if a == "midia":
+                espera(0.4 * passo)
+                js({"musica": td_.musica()})
+
+    try:
+        ident = identidade.ler()
+        js({"nome": ident["nome"]})
+        js({"robo": ident["robo"]})
+    except Exception as e:
+        sys.stderr.write(f"painel_dados: identidade: {e}\n")
+    threading.Thread(target=medir, daemon=True).start()
+    threading.Thread(target=agenda, daemon=True).start()
+    for linha in entrada:           # stdin fechado = o app saiu ou voltou pro chat
+        if parar.is_set():
+            break
+        try:
+            m = json.loads(linha)
+        except ValueError:
+            continue
+        if not isinstance(m, dict):
+            continue
+        try:
+            threading.Thread(target=acao, args=(m,), daemon=True).start()   # ação lenta (osascript) não trava o laço de leitura
+        except Exception as e:
+            sys.stderr.write(f"painel_dados: ação {m.get('acao')}: {e}\n")
+    parar.set()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())