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

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