primocode 8.4.1 → 8.5.0

package/bin/primocode.js

@@ -538,7 +538,11 @@ async function sendPrompt(userText) {
         // conversa inteira.
         await comprimirConversa();
 
-        const r = await runAct(prompt, {
+        // 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);
+
+        const r = await runAct(prompt2, {
             server: state.config.server,
             model: state.config.model,
             effort: state.config.effort,
@@ -564,6 +568,39 @@ async function sendPrompt(userText) {
     refreshPrompt();
 }
 
+/**
+ * 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.
+ *
+ * Mostra o que mudou — o usuário precisa poder discordar do que foi entendido,
+ * não descobrir no fim que o agente fez outra coisa.
+ *
+ * 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('entendendo o pedido').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;
+        console.log(c.dim('  ⎿ entendi assim:'));
+        for (const linha of String(r.prompt).split('\n')) {
+            if (linha.trim()) console.log(c.dim('    ' + linha.trim()));
+        }
+        return r.prompt;
+    } catch {
+        sp.stop();   // refinar é melhoria, não requisito
+        return cru;
+    }
+}
+
 /**
  * Atualiza o resumo da conversa, se já compensar.
  *
@@ -585,7 +622,12 @@ async function comprimirConversa() {
     }
 }
 
+// O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
+// na tela depois de o usuário ter mandado parar.
+let chatEmVoo = null;
+
 async function runChat(promptForModel, userTextForMemory) {
+    chatEmVoo = new AbortController();
     const sp = new Spinner('pensando').start();
     let started = false;
     let text = '';
@@ -595,6 +637,7 @@ async function runChat(promptForModel, userTextForMemory) {
             history: memoria.paraEnviar(state.memoria, state.history),
             model: state.config.model,
             token: state.config.token,
+            sinal: chatEmVoo.signal,
         }, (evt) => {
             if (evt.erro) { if (!started) sp.stop(); console.log('\n' + c.err(ui.friendlyError(evt.erro))); return; }
             if (evt.delta) {
@@ -1066,6 +1109,7 @@ async function main() {
                 if (key.sequence === '\x1b\x1b' || agora - ultimoEsc < 2000) {
                     ultimoEsc = 0;
                     interromper();
+                    if (chatEmVoo) { try { chatEmVoo.abort(); } catch {} }
                     process.stdout.write('\n' + c.warn('  ⏹ parando o agente…') + '\n');
                 } else {
                     ultimoEsc = agora;

package/lib/act.js

@@ -28,7 +28,14 @@ const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
 // fez, ficou feito). A flag é do módulo de propósito: parar o principal para
 // os subagentes junto.
 let PARAR = false;
-function interromper() { PARAR = true; }
+// O pedido que está em voo agora. Sem isto o Esc Esc só valia entre uma
+// rodada e outra: o modelo seguia escrevendo do outro lado e o usuário ficava
+// vendo o spinner girar depois de ter mandado parar.
+let emVoo = null;
+function interromper() {
+    PARAR = true;
+    if (emVoo) { try { emVoo.abort(); } catch {} }
+}
 
 function ident(profundidade) {
     return '  '.repeat(profundidade);
@@ -297,8 +304,9 @@ async function runAct(userPrompt, opts) {
         let streamError = null;
         let streaming = false;
 
+        emVoo = new AbortController();
         try {
-            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent }, (evt) => {
+            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
@@ -316,6 +324,8 @@ async function runAct(userPrompt, opts) {
             throw e;
         }
         sp.stop();
+        emVoo = null;
+        if (PARAR) break;
 
         if (streamError) {
             const amigavel = friendlyError(streamError);

package/lib/api.js

@@ -57,8 +57,17 @@ function request(serverUrl, endpoint, payload, token) {
     });
 }
 
-function requestStream(serverUrl, endpoint, payload, onEvent, token) {
+/**
+ * `sinal` (AbortSignal) corta o pedido NA HORA.
+ *
+ * Sem ele o Esc Esc só era visto entre uma rodada e outra: o modelo continuava
+ * escrevendo do outro lado e o usuário ficava olhando o spinner girar depois
+ * de ter mandado parar. Abortar não é erro — resolve normal, e quem chamou
+ * segue para a checagem de parada.
+ */
+function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
     return new Promise((resolve, reject) => {
+        if (sinal && sinal.aborted) return resolve();
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
         const client = url.protocol === 'https:' ? https : http;
@@ -110,7 +119,19 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token) {
             res.on('error', reject);
         });
 
-        req.on('error', reject);
+        // Abortar fecha o socket e encerra a promessa como sucesso: quem pediu
+        // para parar não quer ver mensagem de erro.
+        let cortado = false;
+        const cortar = () => {
+            if (cortado) return;
+            cortado = true;
+            try { req.destroy(); } catch {}
+            resolve();
+        };
+        if (sinal) sinal.addEventListener('abort', cortar, { once: true });
+
+        req.on('error', (e) => { if (!cortado) reject(e); });
+        req.on('close', () => { if (sinal) sinal.removeEventListener('abort', cortar); });
         req.write(data);
         req.end();
     });
@@ -118,14 +139,14 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token) {
 
 // Agente autônomo. `payload` carrega a conversa completa (messages).
 function requestAct(serverUrl, payload, onEvent) {
-    const { token, ...body } = payload;
-    return requestStream(serverUrl, '/api/act/stream', body, onEvent, token);
+    const { token, sinal, ...body } = payload;
+    return requestStream(serverUrl, '/api/act/stream', body, onEvent, token, sinal);
 }
 
 // Chat puro.
 function requestChat(serverUrl, payload, onEvent) {
-    const { token, ...body } = payload;
-    return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token);
+    const { token, sinal, ...body } = payload;
+    return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token, sinal);
 }
 
 // Resumo incremental da conversa. Vai e volta pequeno: manda o resumo de
@@ -135,6 +156,12 @@ function requestResumo(serverUrl, payload) {
     return request(serverUrl, '/api/resumir', body, token);
 }
 
+// Refino do pedido: manda o texto cru, recebe a ordem de serviço.
+function requestRefino(serverUrl, payload) {
+    const { token, ...body } = payload;
+    return request(serverUrl, '/api/refinar', body, token);
+}
+
 function getHealth(serverUrl, token) {
     return new Promise((resolve, reject) => {
         const url = new URL('/health', serverUrl);
@@ -151,4 +178,4 @@ function getHealth(serverUrl, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, getHealth };

package/lib/referencia.js

@@ -59,6 +59,10 @@ function hostBloqueado(hostname) {
 const TIMEOUT_MS = 12000;
 const MAX_POR_FONTE = 4;
 const MAX_TEXTO = 4500;
+// Quanto HTML baixar antes de parar. Só os primeiros MAX_TEXTO caracteres de
+// TEXTO viram referência, e 400 KB de HTML dão isso com folga em qualquer
+// página — inclusive nas de Wikipédia, que passam desse tamanho.
+const LIMITE_CORPO = 400000;
 
 // Rede de empresa costuma exigir proxy. Sem isto, a pesquisa simplesmente não
 // funciona em metade dos computadores corporativos — e o usuário nunca
@@ -136,13 +140,25 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
                 }
                 if (res.statusCode !== 200) { res.resume(); return resolve(null); }
                 let corpo = '';
+                let pronto = false;
+                const entregar = (valor) => { if (!pronto) { pronto = true; resolve(valor); } };
                 res.setEncoding('utf8');
                 res.on('data', (c) => {
                     corpo += c;
-                    if (corpo.length > 400000) { req.destroy(); }   // página gigante não serve
+                    // Página grande: PARA de baixar e entrega o que já veio.
+                    //
+                    // Antes isto era `req.destroy()` sem entregar nada, e o
+                    // destroy caía no req.on('error') -> resolve(null). Ou
+                    // seja: TODA página acima de 400 KB era jogada fora
+                    // inteira. Artigo de Wikipédia passa desse tamanho, então
+                    // toda pesquisa que caía nela voltava "achei os links mas
+                    // não consegui abrir nenhum" — com a página no ar e o
+                    // conteúdo já na mão. E precisamos só dos primeiros
+                    // milhares de caracteres.
+                    if (corpo.length > LIMITE_CORPO) { res.destroy(); entregar(corpo); }
                 });
-                    res.on('end', () => resolve(corpo));
-                    res.on('error', () => resolve(null));
+                    res.on('end', () => entregar(corpo));
+                    res.on('error', () => entregar(corpo || null));
                 });
             } catch { return resolve(null); }
             req.on('timeout', () => { req.destroy(); resolve(null); });
@@ -151,6 +167,21 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
     });
 }
 
+/**
+ * Isto é texto para ler, ou sobra de código?
+ *
+ * Site feito em construtor visual despeja CSS e JSON no corpo da página. Sem
+ * este filtro o "trecho" entregue ao modelo começava com
+ * `{"css":"@media all { *#dm .dmInner ...` — e era isso que ele levava como
+ * referência para escrever o vídeo.
+ */
+function pareceCodigo(texto) {
+    const amostra = texto.slice(0, 1200);
+    if (!amostra) return true;
+    const simbolos = (amostra.match(/[{};:_#]/g) || []).length;
+    return simbolos / amostra.length > 0.08;
+}
+
 /** HTML → texto legível. Sem dependência: corta script/style e as tags. */
 function textoDe(html) {
     return String(html || '')
@@ -165,6 +196,67 @@ function textoDe(html) {
         .trim();
 }
 
+/**
+ * ── FONTE ERRADA É PIOR QUE FONTE NENHUMA ────────────────────────────────
+ * Pedido real: "pesquise sobre a Paris Group e crie um vídeo para anunciar a
+ * imersão founders ai". Os buscadores não acharam a empresa e a busca de
+ * texto da Wikipédia devolveu o que continha aquelas palavras soltas: Milan,
+ * History of autism, Berlitz Corporation, 42 (school). O agente ia escrever
+ * um vídeo com AQUILO. Melhor devolver "não achei" e deixar o modelo dizer
+ * isso ao usuário do que entregar fonte que não é sobre o assunto.
+ */
+function palavrasDaConsulta(consulta) {
+    return String(consulta || '')
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((p) => p.length >= 3 && !GENERICAS.has(p));
+}
+
+// Palavras que aparecem em qualquer pesquisa e não provam relevância nenhuma.
+const GENERICAS = new Set(['sobre', 'empresa', 'company', 'overview', 'about', 'the', 'and',
+    'para', 'com', 'que', 'dos', 'das', 'quem', 'programa', 'program', 'site', 'oficial']);
+
+/**
+ * O link fala mesmo do que foi pedido?
+ *
+ * Exige DUAS palavras distintas da consulta no título ou na URL — uma só é
+ * coincidência ("Paris - Wikipedia" para "Paris Group founders AI" bate em
+ * "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;
+    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);
+}
+
+/**
+ * O site provável de uma empresa, tentado direto — sem buscador nenhum.
+ *
+ * É como uma pessoa faria: "Paris Group" -> parisgroup.com, parisgroup.ai.
+ * Foi o que salvou este caso — parisgroup.ai abre e tem o texto todo, enquanto
+ * DuckDuckGo devolvia 202 e o Bing devolvia Paris, a cidade.
+ *
+ * Só dispara quando a consulta tem DUAS PALAVRAS COM INICIAL MAIÚSCULA
+ * seguidas, que é como se escreve nome de empresa. "react hooks tutorial" não
+ * dispara; "Paris Group" dispara.
+ */
+function sitesProvaveis(consulta) {
+    const nome = /\b([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\s+([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\b/.exec(String(consulta || ''));
+    if (!nome) return [];
+    const slug = `${nome[1]}${nome[2]}`
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (slug.length < 5) return [];
+    return ['com', 'ai', 'com.br', 'io', 'co'].map((tld) => ({
+        titulo: `${nome[1]} ${nome[2]} — site oficial`,
+        url: `https://www.${slug}.${tld}`,
+        nota: 'site provável da empresa',
+    }));
+}
+
 // Links que não são referência de nada — resultado de busca sujo.
 const LIXO = /(facebook|twitter|x)\.com|instagram|pinterest|youtube\.com\/(?!watch)|\/search\?|duckduckgo|bing\.com\/(?!ck)|google\./i;
 
@@ -256,6 +348,15 @@ async function buscarBing(consulta, limite) {
     const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
     if (!html) return [];
     const pares = [];
+    // O Bing largou o <h2><a href> e hoje mostra a URL num <cite>, com " › "
+    // no lugar da barra. O parser antigo casava ZERO resultados numa página
+    // que trazia dez — e a pesquisa caía na Wikipédia, que era o lixo.
+    const cites = html.match(/<cite[^>]*>[\s\S]{0,200}?<\/cite>/gi) || [];
+    for (const bruto of cites) {
+        const mostrado = textoDe(bruto);
+        if (!/^https?:\/\//i.test(mostrado) || /[…]/.test(mostrado)) continue;
+        pares.push({ titulo: mostrado.replace(/\s*›\s*/g, ' / '), url: mostrado.replace(/\s*›\s*/g, '/') });
+    }
     const re = /<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
     let m;
     while ((m = re.exec(html))) pares.push({ titulo: textoDe(m[2]), url: m[1] });
@@ -352,8 +453,19 @@ async function pesquisar({ consulta, paginas = 3 }) {
     // portas vieram vazias: ela é a melhor fonte, e é o que salva a pesquisa
     // quando os links do buscador não abrem (rede corporativa, site fora do
     // ar, bloqueio). Foi assim que a pesquisa falhava mesmo achando links.
-    const candidatos = [...web, ...so, ...docsConhecidas(termo)]
-        .slice(0, Math.max(2, Math.min(8, paginas + 4)));
+    // O site provável da empresa vai NA FRENTE: quando a consulta nomeia um
+    // negócio, o site dele é a melhor fonte que existe, e não depende de
+    // buscador nenhum estar de bom humor.
+    const chutes = sitesProvaveis(termo);
+    const palavras = palavrasDaConsulta(termo);
+    const brutos = [...chutes, ...web, ...so, ...docsConhecidas(termo)];
+
+    // Fora o que não é sobre o assunto. Sem isto o modelo recebia "Milan" e
+    // "History of autism" para uma pesquisa sobre uma empresa, e escrevia o
+    // vídeo com aquilo.
+    const filtrados = brutos.filter((cand) => cand.nota === 'site provável da empresa' || relevante(cand, palavras));
+    const candidatos = filtrados.slice(0, Math.max(2, Math.min(10, paginas + 6)));
+    const descartados = brutos.length - filtrados.length;
     if (!candidatos.length) {
         return {
             ok: false,
@@ -362,7 +474,9 @@ async function pesquisar({ consulta, paginas = 3 }) {
             // "sem internet?" era o palpite errado, e mandava o usuário conferir
             // a conexão dele: medido, os buscadores devolvem 202/302 e página
             // vazia para quem não parece navegador, com a rede perfeita.
-            provavelCausa: 'Os buscadores costumam recusar chamadas automáticas (bloqueio ou limite por excesso de buscas seguidas), e não a sua conexão.',
+            provavelCausa: descartados
+                ? `Vieram ${descartados} link(s), mas nenhum era sobre "${termo}" — o buscador não achou o assunto e devolveu página aleatória. Fonte errada é pior que fonte nenhuma, então foram descartadas.`
+                : 'Os buscadores costumam recusar chamadas automáticas (bloqueio ou limite por excesso de buscas seguidas), e não a sua conexão.',
             comoCorrigir: 'Tente OUTRA consulta, mais curta e específica. Se souber o site do assunto, vá direto nele com browser_open + browser_read — é o caminho mais confiável para fato de empresa.',
         };
     }
@@ -374,6 +488,12 @@ async function pesquisar({ consulta, paginas = 3 }) {
         if (!html) continue;
         const texto = textoDe(html);
         if (texto.length < 200) continue;
+        if (pareceCodigo(texto)) continue;
+        // O chute de domínio precisa PROVAR que acertou. "Paris Group" tem
+        // 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;
         lidas.push({
             titulo: cand.titulo,
             url: cand.url,
@@ -383,7 +503,14 @@ async function pesquisar({ consulta, paginas = 3 }) {
     }
 
     if (!lidas.length) {
-        return { ok: false, error: 'achei os links mas não consegui abrir nenhum', consulta: termo, links: candidatos.map((c) => c.url) };
+        return {
+            ok: false,
+            error: 'achei os links mas não consegui abrir nenhum',
+            consulta: termo,
+            links: candidatos.map((c) => c.url),
+            comoCorrigir: 'Tente browser_open + browser_read num desses links, ou pesquise com outras palavras. '
+                + 'Se nada abrir, diga ao usuário que não conseguiu confirmar os fatos — NUNCA invente dado sobre empresa, data, preço ou pessoa.',
+        };
     }
 
     return {
@@ -396,4 +523,5 @@ async function pesquisar({ consulta, paginas = 3 }) {
     };
 }
 
-module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG };
+module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG, pegar,
+    relevante, palavrasDaConsulta, sitesProvaveis, pareceCodigo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.4.1",
+  "version": "8.5.0",
   "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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js"
   },
   "engines": {
     "node": ">=18.17.0"