primocode 8.2.0 → 8.2.2

package/lib/act.js

@@ -160,6 +160,37 @@ function summarizeForModel(result) {
     return json.length > 6000 ? json.slice(0, 6000) + '…(truncado)' : json;
 }
 
+// Quantos resultados de tool ficam INTEIROS na conversa. Os mais novos são o
+// que o modelo precisa para decidir o próximo passo; os velhos viram peso.
+const RESULTADOS_INTEIROS = 3;
+const RESTO_DO_RESULTADO = 300;
+
+/**
+ * Encolhe os resultados de tool ANTIGOS antes de mandar a conversa.
+ *
+ * Sem isto, cada página lida e cada pesquisa ficava inteira no histórico para
+ * sempre. Medido num pedido real ("pesquise sobre a empresa X e faça um
+ * vídeo"): cinco pesquisas e seis leituras de página levaram a conversa a
+ * 27.454 tokens contra um teto de 6.000 por minuto do plano grátis — a tarefa
+ * morreu no meio, depois de todo o trabalho de pesquisa já feito.
+ *
+ * Nenhuma mensagem é REMOVIDA: a API exige que cada role:'tool' continue
+ * pareada com o tool_call que a pediu. Só o texto encolhe.
+ */
+function compactar(messages) {
+    const indices = [];
+    for (let i = 0; i < messages.length; i++) if (messages[i].role === 'tool') indices.push(i);
+    if (indices.length <= RESULTADOS_INTEIROS) return messages;
+
+    const encolher = new Set(indices.slice(0, -RESULTADOS_INTEIROS));
+    return messages.map((m, i) => {
+        if (!encolher.has(i)) return m;
+        const texto = String(m.content || '');
+        if (texto.length <= RESTO_DO_RESULTADO) return m;
+        return { ...m, content: texto.slice(0, RESTO_DO_RESULTADO) + `…(resultado antigo encurtado; eram ${texto.length} caracteres)` };
+    });
+}
+
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
     const geral = cfg.readGeneralMemory();
@@ -210,7 +241,7 @@ async function runAct(userPrompt, opts) {
         let streaming = false;
 
         try {
-            await motor.requestAct(server, { messages, model, effort, token, projectDir, projectName, subagent }, (evt) => {
+            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
@@ -271,7 +302,7 @@ async function runAct(userPrompt, opts) {
                     messages.push({
                         role: 'tool',
                         tool_call_id: tc.id,
-                        content: `NÃO terminou. Estas tools falharam e você não corrigiu: ${falhasPendentes.join('; ')}. `
+                        content: `NÃO terminou. Estas tools falharam e você não corrigiu: ${falhasPendentes.map((f) => f.texto).join('; ')}. `
                             + 'Conserte agora (leia o arquivo antes de editar) ou, se for impossível, diga claramente ao usuário o que falhou.',
                     });
                     continue;
@@ -306,12 +337,29 @@ async function runAct(userPrompt, opts) {
             // a lista inteira e o agente conseguia dizer "concluído" com uma
             // falha real ainda pendente.
             if (result && result.ok === false) {
-                falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
-            } else if (['write_file', 'edit_file'].includes(tc.name) && tc.arguments?.path) {
-                const alvo = tc.arguments.path;
-                const mantidas = falhasPendentes.filter((f) => !f.includes(`(${alvo})`));
+                falhasPendentes.push({
+                    tool: tc.name,
+                    alvo: tc.arguments?.path || '',
+                    texto: `${tc.name}(${tc.arguments?.path || ''}): ${result.error}`,
+                });
+            } else {
+                // Deu certo: some com o que ESTA tool tinha deixado pendente.
+                //
+                // Antes só write_file/edit_file limpavam, e por caminho. Uma
+                // falha já superada continuava bloqueando o finish para sempre:
+                // medido num pedido real, o browser_read errou o seletor
+                // ("main"), acertou na tentativa seguinte lendo 5.240 chars — e
+                // mesmo assim a tarefa morreu com "Parei sem concluir. A última
+                // falha foi: browser_read()". Acertar depois de errar é
+                // exatamente o que esta guarda quer premiar, não punir.
+                const alvo = tc.arguments?.path;
+                const sobrou = falhasPendentes.filter((f) => {
+                    if (f.tool === tc.name) return false;                    // a mesma tool funcionou
+                    if (alvo && f.alvo === alvo) return false;               // o mesmo arquivo foi resolvido
+                    return true;
+                });
                 falhasPendentes.length = 0;
-                falhasPendentes.push(...mantidas);
+                falhasPendentes.push(...sobrou);
             }
 
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
@@ -335,7 +383,7 @@ async function runAct(userPrompt, opts) {
     // depois de a primeira tentativa de seletor falhar.
     if (!finalText) {
         finalText = falhasPendentes.length
-            ? `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1]}`
+            ? `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`
             : 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
         if (!subagent) console.log('\n' + c.warn(finalText));
     }
@@ -382,4 +430,4 @@ async function runSubagent(args, ctx) {
     return resumo;
 }
 
-module.exports = { runAct, interromper };
+module.exports = { runAct, interromper, compactar };

package/lib/claude-engine.js

@@ -24,16 +24,55 @@ const MARCA_FIM = '<<<FIM>>>';
  */
 function extrairDecisao(texto) {
     const t = String(texto || '');
-    const inicio = t.lastIndexOf(MARCA_INICIO);
-    if (inicio === -1) return null;
-    const fim = t.indexOf(MARCA_FIM, inicio);
-    if (fim === -1) return null;
-    const bloco = t.slice(inicio + MARCA_INICIO.length, fim).trim();
-    try {
-        return JSON.parse(bloco);
-    } catch {
-        return null;
+
+    // Varre TODOS os blocos completos e fica com o último que dá para ler.
+    //
+    // A versão anterior fazia lastIndexOf(INICIO) e depois procurava o FIM
+    // para frente. Bastava o modelo escrever a marca de abertura mais uma vez
+    // — explicando o formato, ou começando um bloco e desistindo — para o FIM
+    // não existir depois dela: a extração devolvia null e o protocolo CRU ia
+    // parar na tela do usuário, com tool_call e tudo. Foi o que aconteceu num
+    // pedido real de vídeo.
+    const blocos = [];
+    let i = 0;
+    while (true) {
+        const inicio = t.indexOf(MARCA_INICIO, i);
+        if (inicio === -1) break;
+        const fim = t.indexOf(MARCA_FIM, inicio + MARCA_INICIO.length);
+        if (fim === -1) break;                       // bloco aberto e não fechado: ignora
+        blocos.push(t.slice(inicio + MARCA_INICIO.length, fim));
+        i = fim + MARCA_FIM.length;
     }
+
+    for (let k = blocos.length - 1; k >= 0; k--) {
+        const lido = lerJSON(blocos[k]);
+        if (lido) return lido;
+    }
+    return null;
+}
+
+/** O JSON do bloco, tolerando o que o modelo costuma acrescentar sem querer. */
+function lerJSON(bruto) {
+    let s = String(bruto || '').trim();
+    // Cerca de markdown em volta do JSON — o modelo põe por hábito.
+    s = s.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, '').trim();
+    try { return JSON.parse(s); } catch {}
+    // Sobrou texto depois do objeto? Corta no fecha-chaves que casa com o primeiro.
+    const abre = s.indexOf('{');
+    if (abre === -1) return null;
+    let nivel = 0, dentro = false, escapa = false;
+    for (let k = abre; k < s.length; k++) {
+        const c = s[k];
+        if (escapa) { escapa = false; continue; }
+        if (c === '\\') { escapa = true; continue; }
+        if (c === '"') { dentro = !dentro; continue; }
+        if (dentro) continue;
+        if (c === '{') nivel++;
+        else if (c === '}' && --nivel === 0) {
+            try { return JSON.parse(s.slice(abre, k + 1)); } catch { return null; }
+        }
+    }
+    return null;
 }
 
 const catalogo = require('./catalogo');
@@ -229,7 +268,15 @@ function ultimaMensagem(messages) {
 function emitirDecisao(textoLido, onEvent) {
     const decisao = extrairDecisao(textoLido);
     if (!decisao) {
-        onEvent({ assistant_message: { content: String(textoLido || '').trim() } });
+        // Resposta sem bloco legível. Se ela AINDA ASSIM traz a marca do
+        // protocolo, o motor falhou: mostrar isso cru — com "tool_call" e
+        // JSON na cara do usuário — é pior do que dizer que falhou.
+        let conteudo = String(textoLido || '').trim();
+        if (conteudo.includes(MARCA_INICIO) || conteudo.includes(MARCA_FIM)) {
+            conteudo = conteudo.split(MARCA_INICIO)[0].trim()
+                || 'O motor Claude Code devolveu uma decisão que não consegui ler. Tente de novo, ou volte ao motor padrão com /claude off.';
+        }
+        onEvent({ assistant_message: { content: conteudo } });
         return;
     }
     if (decisao.tool_call) {

package/lib/referencia.js

@@ -102,10 +102,17 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
         if (hostBloqueado(alvo.hostname)) return resolve(null);
         const cliente = alvo.protocol === 'http:' ? http : https;
 
+        // O User-Agent precisa parecer navegador. Buscador nenhum responde a
+        // agente desconhecido: DuckDuckGo, Bing e Searx devolviam página VAZIA
+        // para o 'PrimoCode/1.0' — e o usuário via "nada encontrado (sem
+        // internet?)" com a internet funcionando perfeitamente. Site comum não
+        // liga para isso, e por isso as páginas abriam: só a BUSCA morria.
         const opcoes = {
             headers: {
-                'User-Agent': 'PrimoCode/1.0 (+https://github.com/ConectaPrimoAI/primocode)',
-                Accept: 'text/html,application/json;q=0.9,*/*;q=0.8',
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 '
+                    + '(KHTML, like Gecko) Chrome/122.0 Safari/537.36',
+                Accept: 'text/html,application/xhtml+xml,application/json;q=0.9,*/*;q=0.8',
+                'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8',
             },
             timeout,
         };
@@ -191,6 +198,59 @@ async function buscarDDG(consulta, limite) {
     return limparLinks(pares, limite);
 }
 
+/**
+ * Wikipedia — a fonte que NÃO bloqueia.
+ *
+ * Buscador raspado por HTML (DDG, Bing, Searx) recusa quem não parece gente:
+ * devolve 202/302 e página vazia, e o usuário lê "nada encontrado (sem
+ * internet?)" com a internet ótima. Medido: no IP deste servidor os três
+ * calaram juntos, enquanto a API da Wikipedia respondeu 200 na hora.
+ *
+ * É API pública e estável, feita para ser consumida por programa — e para
+ * empresa, pessoa, cidade e evento costuma ser a MELHOR fonte, não a pior.
+ */
+async function buscarWikipedia(consulta, limite) {
+    const achados = [];
+    for (const lingua of ['pt', 'en']) {
+        if (achados.length >= limite) break;
+        const url = `https://${lingua}.wikipedia.org/w/api.php?action=query&list=search`
+            + `&srsearch=${encodeURIComponent(consulta)}&format=json&srlimit=${limite}`;
+        const bruto = await pegar(url);
+        if (!bruto) continue;
+        let j;
+        try { j = JSON.parse(bruto); } catch { continue; }
+        for (const r of (j.query && j.query.search) || []) {
+            achados.push({
+                titulo: r.title,
+                url: `https://${lingua}.wikipedia.org/wiki/${encodeURIComponent(r.title.replace(/ /g, '_'))}`,
+                nota: 'Wikipédia',
+            });
+            if (achados.length >= limite) break;
+        }
+    }
+    return achados;
+}
+
+/**
+ * A resposta direta do DuckDuckGo (API oficial, sem raspagem).
+ *
+ * Não é busca de links: é o resumo que ele já tem sobre o assunto, mais os
+ * tópicos relacionados. Responde 200 onde a página de busca devolve 202.
+ */
+async function buscarRespostaDDG(consulta, limite) {
+    const bruto = await pegar(`https://api.duckduckgo.com/?q=${encodeURIComponent(consulta)}&format=json&no_html=1&skip_disambig=1`);
+    if (!bruto) return [];
+    let j;
+    try { j = JSON.parse(bruto); } catch { return []; }
+    const achados = [];
+    if (j.AbstractURL) achados.push({ titulo: j.Heading || consulta, url: j.AbstractURL, nota: j.AbstractSource });
+    for (const t of j.RelatedTopics || []) {
+        if (achados.length >= limite) break;
+        if (t.FirstURL) achados.push({ titulo: (t.Text || '').slice(0, 120), url: t.FirstURL });
+    }
+    return limparLinks(achados, limite);
+}
+
 /** Bing (HTML) — a reserva quando o DDG não responde. */
 async function buscarBing(consulta, limite) {
     const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
@@ -218,13 +278,24 @@ async function buscarSearx(consulta, limite) {
  * pesquisa inteira. Sem chave de API em nenhuma delas.
  */
 async function buscar(consulta, limite = MAX_POR_FONTE) {
-    for (const porta of [buscarDDG, buscarBing, buscarSearx]) {
+    // Ordem deliberada: primeiro os buscadores raspados (dão os links mais
+    // frescos, quando respondem), depois as APIs que NUNCA bloqueiam. Antes a
+    // fila acabava no Searx e, com os três calados, a pesquisa inteira voltava
+    // vazia — mesmo havendo resposta boa na Wikipédia.
+    const portas = [buscarDDG, buscarBing, buscarSearx, buscarRespostaDDG, buscarWikipedia];
+    const juntos = [];
+    for (const porta of portas) {
         try {
             const achados = await porta(consulta, limite);
-            if (achados.length) return achados;
+            for (const a of achados) {
+                if (!juntos.some((j) => j.url === a.url)) juntos.push(a);
+            }
+            // Os raspados, quando respondem, já bastam. As APIs entram para
+            // completar quando eles vieram vazios.
+            if (juntos.length >= limite) break;
         } catch {}
     }
-    return [];
+    return juntos.slice(0, limite);
 }
 
 /** Respostas do StackOverflow — a API pública, sem chave. */
@@ -284,7 +355,16 @@ async function pesquisar({ consulta, paginas = 3 }) {
     const candidatos = [...web, ...so, ...docsConhecidas(termo)]
         .slice(0, Math.max(2, Math.min(8, paginas + 4)));
     if (!candidatos.length) {
-        return { ok: false, error: `nada encontrado para "${termo}" (sem internet?)`, consulta: termo };
+        return {
+            ok: false,
+            error: `Nenhuma fonte respondeu sobre "${termo}".`,
+            consulta: termo,
+            // "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.',
+            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.',
+        };
     }
 
     const lidas = [];
@@ -316,4 +396,4 @@ async function pesquisar({ consulta, paginas = 3 }) {
     };
 }
 
-module.exports = { pesquisar, buscar, stackoverflow, textoDe };
+module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG };

package/lib/studio.js

@@ -41,8 +41,31 @@ const BASE = `http://127.0.0.1:${PORTA}`;
 // criou) nunca são tocados.
 const COPIAVEIS = new Set(['server.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
 
+/**
+ * Onde está o Python 3 desta máquina.
+ *
+ * Procurar só por `python3` no PATH não basta, e isso custou uma tarefa
+ * inteira num Mac: o comando existe mas é o atalho da Apple, que sem as
+ * Ferramentas de Linha de Comando instaladas sai com erro em vez de versão —
+ * e o usuário lia "Python 3 não está instalado" com o Python instalado pelo
+ * Homebrew ali do lado, fora do PATH daquele terminal.
+ *
+ * Então: nomes comuns, versões numeradas, e os caminhos absolutos onde o
+ * Python realmente mora em cada sistema.
+ */
 function pythonCmd() {
-    const candidatos = os.platform() === 'win32' ? ['python', 'py', 'python3'] : ['python3', 'python'];
+    const numeradas = ['python3.13', 'python3.12', 'python3.11', 'python3.10', 'python3.9'];
+    let candidatos;
+    if (os.platform() === 'win32') {
+        candidatos = ['python', 'py', 'python3', ...numeradas];
+    } else {
+        candidatos = [
+            'python3', 'python', ...numeradas,
+            // Homebrew (Apple Silicon e Intel) e o do sistema — o PATH de um
+            // terminal aberto por atalho às vezes não tem nenhum dos dois.
+            '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3',
+        ];
+    }
     for (const c of candidatos) {
         try {
             const v = execSync(`${c} --version`, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString();
@@ -130,10 +153,16 @@ async function garantirNoAr() {
         if (!py) {
             return {
                 ok: false,
-                error: 'O Studio precisa do Python 3, que não está instalado.',
+                error: 'O Studio precisa do Python 3, e não achei nenhum nesta máquina.',
                 comoResolver: os.platform() === 'darwin'
-                    ? 'Instale com: brew install python3 (ou baixe em python.org).'
-                    : 'Instale o Python 3 (python.org) e tente de novo.',
+                    ? 'No Mac, o mais rápido é: xcode-select --install (traz o Python 3 da Apple). '
+                      + 'Ou, se você usa Homebrew: brew install python. Depois é só pedir de novo.'
+                    : os.platform() === 'win32'
+                        ? 'Instale em python.org/downloads (marque "Add python.exe to PATH" no instalador).'
+                        : 'Instale o Python 3 pelo gerenciador da sua distribuição (ex: sudo apt install python3).',
+                // Sem isto o agente responde "não consegui" e para. O trabalho
+                // pedido quase sempre tem um caminho que não depende do Studio.
+                enquantoIsso: 'Não desista da tarefa: dá para entregar em HTML com write_file e abrir com open_in_browser.',
             };
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.2.0",
+  "version": "8.2.2",
   "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"
+    "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"
   },
   "engines": {
     "node": ">=18.17.0"