primocode 8.2.0 → 8.2.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.2.0",
+  "version": "8.2.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": {
@@ -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"