primocode 8.8.0 → 8.9.1

package/bin/primocode.js

@@ -540,11 +540,11 @@ async function sendPrompt(userText) {
 
         // O pedido passa por uma cabeça antes de virar trabalho: conserta o
         // que está torto, diz qual é o entregável e o que conta como pronto.
-        const prompt2 = await refinarPedido(prompt);
-
-        // A tarefa grande vira passos, e cada passo é uma chamada própria — com
-        // conversa nova, e por isso pequena. Oculto: o usuário mandou UMA coisa.
-        const passos = await dividirTarefa(prompt2);
+        // UMA chamada faz as duas coisas: arruma o pedido torto e, se fizer
+        // sentido, divide em passos. Eram duas idas ao modelo por pedido, e
+        // num plano limitado por REQUISIÇÕES (o grátis da Groq são 30 por
+        // minuto) cada chamada extra custa tanto quanto token.
+        const passos = await dividirTarefa(prompt);
 
         let r = null;
         let jaFeito = '';
@@ -585,66 +585,43 @@ async function sendPrompt(userText) {
 }
 
 /**
- * Divide a tarefa grande em passos — e faz isso ESCONDIDO.
+ * Arruma o pedido e divide em passos — as duas coisas, ESCONDIDAS.
+ *
+ * ARRUMAR: gente pede curto e torto ("cria um vidro anunciando o founders
+ * ai"). Sem isso o agente adivinha, e adivinha errado. É oculto porque
+ * encanamento não é conversa: o usuário quer ver a coisa acontecendo, não um
+ * relatório do que a máquina entendeu — e não há o que aprovar, já que o
+ * refino não decide nada, só desambigua o que ele já disse.
  *
- * O motivo é aritmético. Com 6.000 tokens por minuto, "pesquise sobre a X e
- * crie um vídeo" não cabe numa conversa só: o custo fixo (prompt + tools) é
- * ~3.700, a spec do formato ~1.400, os fatos da pesquisa o resto — e sobram
- * 512 para o agente escrever o documento. Em DOIS pedidos cada um cabe
- * folgado, porque cada um leva só as ferramentas e o prompt do seu passo.
+ * DIVIDIR: o motivo é aritmético. Com 6.000 tokens por minuto, "pesquise
+ * sobre a X e crie um vídeo" não cabe numa conversa só — custo fixo ~3.700,
+ * spec do formato ~1.400, fatos da pesquisa o resto, e sobram 512 para o
+ * agente escrever. Em dois pedidos cada um cabe folgado, porque cada um leva
+ * só as ferramentas e o prompt do seu passo.
  *
- * O dono queria isto automático: "o usuário manda a tarefa gigante, e a IA
- * ocultamente vai quebrar a tarefa". E com razão — quem pede não sabe onde
- * está a fronteira barata, e pode partir num pedaço que ainda não cabe.
+ * As duas numa chamada só: elas leem o mesmo texto, e num plano limitado por
+ * requisições por minuto a segunda ida ao modelo custa tanto quanto token.
  *
- * Falhou? Um passo só, que é o comportamento de sempre.
+ * Falhou? O pedido do usuário, inteiro, como ele escreveu.
  */
 async function dividirTarefa(pedido) {
     const inteiro = [{ titulo: 'tarefa', pedido }];
+    if (!pedido || pedido.trim().length < 12) return inteiro;
+    const sp = new Spinner('Primo Code pensando').start();
     try {
         const r = await api.requestPlano(state.config.server, {
             prompt: pedido, model: state.config.model, token: state.config.token,
         });
+        sp.stop();
         const passos = (r && Array.isArray(r.passos) && r.passos.length) ? r.passos : inteiro;
         if (passos.length > 1) console.log(c.dim(`  ⎿ ${passos[0].titulo}`));
         return passos;
     } catch {
+        sp.stop();   // preparar o pedido é melhoria, não requisito
         return inteiro;
     }
 }
 
-/**
- * Estrutura o pedido antes de mandar o agente executar.
- *
- * Gente pede curto e torto — "cria um vidro anunciando o founders ai". Sem
- * isto o agente adivinha, e adivinha errado: sai o genérico, ou ele pesquisa
- * em círculo porque não sabe o que é "pronto". Uma passada barata antes de
- * começar vira ordem de serviço: o que entregar, com que fatos, quando parar.
- *
- * É OCULTO de propósito. A primeira versão mostrava "entendi assim:" na tela,
- * e o dono cortou: encanamento não é conversa. O usuário pediu uma coisa e
- * quer ver a coisa acontecendo, não um relatório do que a máquina entendeu.
- * O refino também não decide nada — só desambigua o que ele já disse —, então
- * não há o que ele precise aprovar.
- *
- * Nunca bloqueia: se o refino falhar ou vier estranho, vale o pedido original.
- */
-async function refinarPedido(cru) {
-    if (!cru || cru.trim().length < 12) return cru;
-    const sp = new Spinner('Primo Code pensando').start();
-    try {
-        const r = await api.requestRefino(state.config.server, {
-            prompt: cru, model: state.config.model, token: state.config.token,
-        });
-        sp.stop();
-        if (!r || !r.refinado || !r.prompt) return cru;
-        return r.prompt;
-    } catch {
-        sp.stop();   // refinar é melhoria, não requisito
-        return cru;
-    }
-}
-
 /**
  * Atualiza o resumo da conversa, se já compensar.
  *

package/lib/referencia.js

@@ -224,13 +224,17 @@ const GENERICAS = new Set(['sobre', 'empresa', 'company', 'overview', 'about', '
  * "paris" e não tem nada a ver). Consulta de uma palavra só se contenta com
  * ela mesma.
  */
-function relevante(cand, palavras) {
-    if (!palavras.length) return true;
+function quantoBate(cand, palavras) {
     const alvo = `${cand.titulo || ''} ${cand.url || ''}`
         .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
     let batidas = 0;
     for (const p of palavras) if (alvo.includes(p)) batidas++;
-    return batidas >= Math.min(2, palavras.length);
+    return batidas;
+}
+
+function relevante(cand, palavras) {
+    if (!palavras.length) return true;
+    return quantoBate(cand, palavras) >= Math.min(2, palavras.length);
 }
 
 /**
@@ -482,6 +486,9 @@ async function pesquisar({ consulta, paginas = 3 }) {
     }
 
     const lidas = [];
+    // Os chutes de domínio ficam de lado até o fim: só então dá para saber
+    // qual deles fala mais do assunto.
+    const chutesLidos = [];
     for (const cand of candidatos) {
         if (lidas.length >= paginas) break;
         const html = await pegar(cand.url);
@@ -493,7 +500,16 @@ async function pesquisar({ consulta, paginas = 3 }) {
         // parisgroup.com (um grupo de varejo no exterior) e parisgroup.ai (a
         // empresa que o usuário quis). O nome não distingue os dois — o texto
         // da página, sim. Sem esta prova o agente escreveria sobre a errada.
-        if (cand.nota === 'site provável da empresa' && !relevante({ titulo: texto.slice(0, 3000), url: cand.url }, palavras)) continue;
+        const ehChute = cand.nota === 'site provável da empresa';
+        if (ehChute) {
+            const nota = quantoBate({ titulo: texto.slice(0, 4000), url: cand.url }, palavras);
+            if (nota < Math.min(2, palavras.length)) continue;
+            // Passar não basta: entre dois domínios do MESMO nome, fica o que
+            // fala mais do assunto. parisgroup.ai e parisgroup.co os dois
+            // "batiam", e o agente recebia as duas empresas como se fossem uma.
+            chutesLidos.push({ nota, item: { titulo: cand.titulo, url: cand.url, nota: cand.nota, trecho: texto.slice(0, MAX_TEXTO) } });
+            continue;
+        }
         lidas.push({
             titulo: cand.titulo,
             url: cand.url,
@@ -502,6 +518,14 @@ async function pesquisar({ consulta, paginas = 3 }) {
         });
     }
 
+    // O melhor chute entra na frente: quando a empresa tem site, ele é a
+    // fonte mais confiável que existe sobre ela.
+    if (chutesLidos.length) {
+        chutesLidos.sort((a, b) => b.nota - a.nota);
+        lidas.unshift(chutesLidos[0].item);
+        if (lidas.length > paginas) lidas.length = paginas;
+    }
+
     if (!lidas.length) {
         return {
             ok: false,
@@ -524,4 +548,4 @@ async function pesquisar({ consulta, paginas = 3 }) {
 }
 
 module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG, pegar,
-    relevante, palavrasDaConsulta, sitesProvaveis, pareceCodigo };
+    relevante, quantoBate, palavrasDaConsulta, sitesProvaveis, pareceCodigo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.8.0",
+  "version": "8.9.1",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/studio/server.py

@@ -15,6 +15,7 @@ import mimetypes
 import os
 import re
 import sys
+import time
 import unicodedata
 import uuid
 from datetime import datetime, timezone
@@ -461,6 +462,8 @@ class Handler(SimpleHTTPRequestHandler):
 
         if p == "/api/voz":
             return self.voz(urlparse(self.path).query)
+        if p == "/api/voz/status":
+            return self.voz_status()
 
         if p == "/api/midia":
             return self.js(listar_midia())
@@ -506,20 +509,128 @@ class Handler(SimpleHTTPRequestHandler):
         if len(texto) > 4000:
             texto = texto[:4000]
 
-        try:
-            audio = b"".join(self._trecho_de_voz(t, idioma) for t in _picar(texto, 190))
-        except Exception as e:                      # rede, bloqueio, mudança do serviço
-            return self.js({"erro": "voz indisponível: %s" % e}, 502)
+        voz = (q.get("voz", [""])[0] or "").strip()
+        instrucao = (q.get("instrucao", [""])[0] or "").strip()
+        motor = (q.get("motor", [""])[0] or "").strip()
+
+        tipo = "audio/mpeg"
+        audio = b""
+        # 1) Voicebox, se o usuário tiver instalado: voz clonável, ilimitada e
+        #    sem depender de nada na internet.
+        if motor != "google" and self._voicebox_vivo():
+            try:
+                audio, tipo = self._voz_voicebox(texto, voz, instrucao)
+            except Exception as e:
+                sys.stderr.write("[voz] Voicebox falhou (%s); indo de Google\n" % e)
+                audio = b""
+        # 2) Google: uma voz só, mas responde sempre.
+        if not audio:
+            try:
+                audio = b"".join(self._trecho_de_voz(t, idioma) for t in _picar(texto, 190))
+            except Exception as e:                  # rede, bloqueio, mudança do serviço
+                return self.js({"erro": "voz indisponível: %s" % e}, 502)
         if not audio:
             return self.js({"erro": "voz não devolveu áudio"}, 502)
 
         self.send_response(200)
-        self.send_header("Content-Type", "audio/mpeg")
+        self.send_header("Content-Type", tipo)
         self.send_header("Content-Length", str(len(audio)))
         self.send_header("Cache-Control", "no-store")
         self.end_headers()
         self.wfile.write(audio)
 
+    # ── Voicebox ───────────────────────────────────────────────────────
+    # https://voicebox.sh — app local, código aberto, de graça e sem limite,
+    # com clonagem de voz. É a melhor voz que existe para este uso e não
+    # depende de serviço nenhum na internet: roda na máquina do usuário.
+    #
+    # A ponte é FEITA AQUI, e não no navegador, por causa do CORS: o Voicebox
+    # só libera as portas dele (5173 e 17493), e o Studio serve em 7777 — do
+    # navegador o pedido morreria antes de sair.
+    #
+    # Não está instalado? A rota cai para o Google, e ninguém fica sem voz.
+    VOICEBOX = "http://127.0.0.1:17493"
+
+    def voz_status(self):
+        """O que está disponível para narrar, para a interface não oferecer o
+        que não existe."""
+        vivo = self._voicebox_vivo()
+        vozes = []
+        if vivo:
+            try:
+                with urllib.request.urlopen(self.VOICEBOX + "/profiles", timeout=6) as r:
+                    vozes = [{"id": v.get("id"), "nome": v.get("name"), "idioma": v.get("language")}
+                             for v in json.loads(r.read().decode("utf-8"))]
+            except Exception:
+                vozes = []
+        return self.js({
+            "voicebox": {"ativo": vivo, "vozes": vozes, "site": "https://voicebox.sh"},
+            "google": {"ativo": True},
+        })
+
+    def _voicebox_vivo(self):
+        try:
+            with urllib.request.urlopen(self.VOICEBOX + "/health", timeout=2):
+                return True
+        except Exception:
+            return False
+
+    def _voicebox_perfil(self, pedido):
+        """A voz a usar: a que o usuário pediu pelo nome, ou a primeira que
+        houver. Sem perfil não há geração — o Voicebox exige um."""
+        req = urllib.request.Request(self.VOICEBOX + "/profiles")
+        with urllib.request.urlopen(req, timeout=8) as r:
+            perfis = json.loads(r.read().decode("utf-8"))
+        if not perfis:
+            raise RuntimeError("Voicebox está no ar mas sem nenhuma voz criada")
+        if pedido:
+            alvo = pedido.strip().lower()
+            for p in perfis:
+                if alvo in (p.get("name") or "").lower() or alvo == p.get("id"):
+                    return p
+        # Sem escolha explícita, prefere uma voz em português.
+        for p in perfis:
+            if (p.get("language") or "").startswith("pt"):
+                return p
+        return perfis[0]
+
+    def _voz_voicebox(self, texto, voz, instrucao):
+        perfil = self._voicebox_perfil(voz)
+        corpo = json.dumps({
+            "profile_id": perfil["id"],
+            "text": texto[:50000],
+            "language": "pt",
+            # A instrução de entrega é o que dá voz de cinema em vez de voz de
+            # leitura. O Voicebox aceita em linguagem natural, até 500 chars.
+            "instruct": (instrucao or "Narração institucional: voz grave, ritmo pausado, tom seguro.")[:500],
+            "max_chunk_chars": 800,
+            "crossfade_ms": 50,
+            "normalize": True,
+        }).encode("utf-8")
+        req = urllib.request.Request(self.VOICEBOX + "/generate", data=corpo,
+                                     headers={"Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=30) as r:
+            g = json.loads(r.read().decode("utf-8"))
+        gid = g.get("id")
+        if not gid:
+            raise RuntimeError("Voicebox não devolveu id de geração")
+
+        # /generate volta na hora com status "generating" e sintetiza em
+        # segundo plano — então é preciso esperar de verdade.
+        prazo = time.time() + 180
+        estado = g.get("status")
+        while estado in (None, "generating", "pending", "processing"):
+            if time.time() > prazo:
+                raise RuntimeError("Voicebox demorou demais")
+            time.sleep(1.0)
+            with urllib.request.urlopen(self.VOICEBOX + "/generate/%s/status" % gid, timeout=8) as r:
+                estado = (json.loads(r.read().decode("utf-8")) or {}).get("status")
+        if estado != "completed":
+            raise RuntimeError("Voicebox falhou (%s)" % estado)
+
+        with urllib.request.urlopen(self.VOICEBOX + "/audio/%s" % gid, timeout=30) as r:
+            return r.read(), (r.headers.get("Content-Type") or "audio/wav")
+
     def _trecho_de_voz(self, texto, idioma):
         url = "https://translate.google.com/translate_tts?" + urlencode({
             "ie": "UTF-8", "q": texto, "tl": idioma, "client": "tw-ob", "total": 1, "idx": 0,