primocode 8.2.1 → 8.4.0

package/bin/primocode.js

@@ -24,6 +24,7 @@ const claudeEngine = require('../lib/claude-engine');
 const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
+const memoria = require('../lib/memoria-conversa');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -50,6 +51,9 @@ const state = {
     mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
     modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
     attachedFiles: [],
+    // O resumo incremental da conversa — um /compact automático. O porquê
+    // está em lib/memoria-conversa.js.
+    memoria: memoria.nova(),
     lastResponse: '',
     currentProject: null,
     workDir: null,     // pasta onde o agente trabalha nesta sessão
@@ -529,12 +533,17 @@ async function sendPrompt(userText) {
     if (modo === 'primocode') {
         const plan = prepararPasta(userText);
 
+        // Antes de gastar com a tarefa, dobra no resumo o que já passou. A
+        // conta é pequena: entra "resumo de antes + o que é novo", não a
+        // conversa inteira.
+        await comprimirConversa();
+
         const r = await runAct(prompt, {
             server: state.config.server,
             model: state.config.model,
             effort: state.config.effort,
             token: state.config.token,
-            history: state.history,
+            history: memoria.paraEnviar(state.memoria, state.history),
             projectDir: plan.dir,
             projectName: plan.name || state.currentProject,
             // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
@@ -547,6 +556,7 @@ async function sendPrompt(userText) {
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
     } else {
+        await comprimirConversa();
         await runChat(prompt, userText);
     }
 
@@ -554,6 +564,27 @@ async function sendPrompt(userText) {
     refreshPrompt();
 }
 
+/**
+ * Atualiza o resumo da conversa, se já compensar.
+ *
+ * Silencioso quando não há o que fazer: nas primeiras rodadas a conversa é
+ * curta e o resumo não pagaria a chamada.
+ */
+async function comprimirConversa() {
+    if (!memoria.precisaResumir(state.memoria, state.history)) return;
+    const sp = new Spinner('resumindo a conversa').start();
+    try {
+        state.memoria = await memoria.atualizar(state.memoria, state.history, ({ resumo, mensagens }) =>
+            api.requestResumo(state.config.server, { resumo, mensagens, token: state.config.token })
+                .then((r) => r.resumo));
+        sp.stop();
+        const e = memoria.economia(state.memoria, state.history);
+        if (e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
+    } catch {
+        sp.stop();   // resumo é economia, não requisito: falhou, segue a vida
+    }
+}
+
 async function runChat(promptForModel, userTextForMemory) {
     const sp = new Spinner('pensando').start();
     let started = false;
@@ -561,7 +592,7 @@ async function runChat(promptForModel, userTextForMemory) {
     try {
         await api.requestChat(state.config.server, {
             prompt: promptForModel,
-            history: state.history.slice(-20),
+            history: memoria.paraEnviar(state.memoria, state.history),
             model: state.config.model,
             token: state.config.token,
         }, (evt) => {
@@ -854,7 +885,7 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'clear': state.history = []; console.log(c.ok('Conversa limpa.')); break;
+        case 'clear': state.history = []; state.memoria = memoria.nova(); console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         case 'status': {
@@ -872,6 +903,14 @@ async function handleSlash(text) {
                     console.log(c.dim(`  Reservas: ${fila.length - 1}`));
                 }
             } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
+            // A memória da conversa: quanto ela está poupando por pedido.
+            if (state.history.length) {
+                const e = memoria.economia(state.memoria, state.history);
+                console.log(c.muted(`  Conversa: ${state.history.length} mensagens`)
+                    + (state.memoria.resumo
+                        ? c.dim(`  · resumida, ${e.enxuto} tokens por pedido em vez de ${e.cheio}`)
+                        : c.dim(`  · ${e.enxuto} tokens por pedido`)));
+            }
             break;
         }
 

package/lib/api.js

@@ -128,6 +128,13 @@ function requestChat(serverUrl, payload, onEvent) {
     return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token);
 }
 
+// Resumo incremental da conversa. Vai e volta pequeno: manda o resumo de
+// antes + o que é novo, recebe o resumo atualizado.
+function requestResumo(serverUrl, payload) {
+    const { token, ...body } = payload;
+    return request(serverUrl, '/api/resumir', body, token);
+}
+
 function getHealth(serverUrl, token) {
     return new Promise((resolve, reject) => {
         const url = new URL('/health', serverUrl);
@@ -144,4 +151,4 @@ function getHealth(serverUrl, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, getHealth };

package/lib/memoria-conversa.js

@@ -0,0 +1,124 @@
+/**
+ * memoria-conversa.js — a conversa que não engorda.
+ *
+ * ── O PROBLEMA ───────────────────────────────────────────────────────────
+ * O histórico ia inteiro (as últimas 20 mensagens) em todo pedido. Numa
+ * conversa de trabalho isso vira milhares de tokens repetidos a cada rodada, e
+ * num plano com teto por minuto a tarefa morre no meio — depois de o esforço
+ * já ter sido gasto. Cortar pelas últimas N é pior ainda: some justamente o
+ * começo, onde está o que o usuário pediu.
+ *
+ * ── A IDEIA (do dono) ────────────────────────────────────────────────────
+ * Resumo INCREMENTAL, como um /compact automático: guarda-se um resumo do que
+ * já passou e, a cada rodada, só o PEDAÇO NOVO é dobrado nele. A primeira vez
+ * custa; da segunda em diante o resumo já existe e só o que foi dito a mais
+ * precisa ser lido.
+ *
+ * O custo fica limitado por construção: a entrada do resumo é sempre
+ * "resumo de antes + o que aconteceu desde então", nunca a conversa inteira.
+ *
+ * ── O QUE NUNCA É RESUMIDO ───────────────────────────────────────────────
+ * As últimas rodadas vão CRUAS. Resumo é bom para lembrar do que foi feito,
+ * péssimo para continuar de onde parou: "agora põe música de fundo" precisa da
+ * frase anterior literal, não de um tópico dizendo que houve um vídeo.
+ *
+ * Este arquivo é puro — quem fala com o servidor é quem chama `atualizar`.
+ * Assim o teste mede a política inteira sem rede e sem chave de API.
+ */
+
+'use strict';
+
+/** ~4 caracteres por token. Mesma conta do servidor, e boa o bastante aqui. */
+function tokensDe(x) {
+    const texto = typeof x === 'string' ? x : JSON.stringify(x || '');
+    return Math.ceil(texto.length / 4);
+}
+
+// Quantas mensagens do fim ficam sempre cruas (o "de onde parei").
+const CRUAS = 4;
+// Acima disto, a cauda vira resumo. Abaixo, não compensa pagar a chamada.
+const LIMITE_TOKENS = 700;
+
+/** Estado inicial — o que o CLI guarda entre um pedido e outro. */
+function nova() {
+    return { resumo: '', resumidasAte: 0 };
+}
+
+/**
+ * O que ainda não foi resumido e já não cabe entre as cruas.
+ * É exatamente o que a próxima chamada de resumo precisa ler.
+ */
+function pendentes(memoria, history) {
+    const fim = Math.max(0, (history || []).length - CRUAS);
+    if (fim <= memoria.resumidasAte) return [];
+    return history.slice(memoria.resumidasAte, fim);
+}
+
+/** Vale a pena pagar uma chamada de resumo agora? */
+function precisaResumir(memoria, history) {
+    const novas = pendentes(memoria, history);
+    if (!novas.length) return false;
+    return tokensDe(novas) >= LIMITE_TOKENS;
+}
+
+/**
+ * Dobra o pedaço novo no resumo. `resumir` é quem fala com o servidor:
+ * recebe { resumo, mensagens } e devolve o texto do resumo atualizado.
+ *
+ * Devolve SEMPRE uma memória utilizável — se o resumo falhar (rede, cota), a
+ * anterior continua valendo e a conversa segue com o histórico cru.
+ */
+async function atualizar(memoria, history, resumir) {
+    const novas = pendentes(memoria, history);
+    if (!novas.length) return memoria;
+
+    let texto;
+    try {
+        texto = await resumir({ resumo: memoria.resumo, mensagens: novas });
+    } catch {
+        return memoria;
+    }
+    const limpo = String(texto || '').trim();
+    if (!limpo) return memoria;
+
+    return { resumo: limpo, resumidasAte: (history || []).length - CRUAS };
+}
+
+/**
+ * Onde a parte crua pode começar sem deixar resultado órfão.
+ *
+ * A API recusa um `role:'tool'` sem o turno do assistente que o pediu. Cortar
+ * "as últimas N" cai nisso na hora em que a conta não bate — então o começo
+ * recua até um ponto onde a rodada está inteira.
+ */
+function inicioSeguro(todas, alvo) {
+    let i = Math.max(0, Math.min(alvo, todas.length));
+    while (i > 0 && todas[i] && todas[i].role === 'tool') i--;
+    return i;
+}
+
+/**
+ * O histórico que vai no pedido: o resumo (se houver) + as últimas cruas.
+ *
+ * O resumo entra como mensagem de sistema, não como fala do usuário — o modelo
+ * precisa saber que aquilo é memória, e não algo que alguém acabou de dizer.
+ */
+function paraEnviar(memoria, history) {
+    const todas = history || [];
+    if (!memoria || !memoria.resumo) return todas.slice(inicioSeguro(todas, todas.length - 20));
+
+    const cruas = todas.slice(inicioSeguro(todas, todas.length - CRUAS));
+    return [
+        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}` },
+        ...cruas,
+    ];
+}
+
+/** Quanto este jeito economiza — para o /status e para o teste provarem. */
+function economia(memoria, history) {
+    const cheio = tokensDe((history || []).slice(-20));
+    const enxuto = tokensDe(paraEnviar(memoria, history));
+    return { cheio, enxuto, poupado: Math.max(0, cheio - enxuto) };
+}
+
+module.exports = { nova, pendentes, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };

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.1",
+  "version": "8.4.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"
+    "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"
   },
   "engines": {
     "node": ">=18.17.0"