primocode 9.5.0 → 9.6.0

package/lib/cursor.js

@@ -0,0 +1,120 @@
+/**
+ * cursor.js — o lado Node do cursor do Primo (só macOS).
+ *
+ *   "Quando ele tá no modo, eu consigo ver o cursor dele, o mouse, ver ele
+ *    digitando, abrindo as coisas, ver ele fazer as coisas em tempo real."
+ *
+ * O cursor mora em voz/primo_voz/cursor.py: um processo Python que mexe no
+ * mouse e no teclado de verdade (Quartz) e desenha a seta dele por cima. Aqui
+ * é a ponta de cá: subir o processo na PRIMEIRA ação no computador (não antes
+ * — quem só escreve código nunca paga por ele), mandar os comandos e esperar
+ * cada um terminar.
+ *
+ * ── POR QUE ELE, E NÃO O cliclick ───────────────────────────────────────
+ * O cliclick precisava de Homebrew, e sem ele TODO clique do agente falhava —
+ * foi o que fez "mostra o teu mouse" virar uma página HTML com coordenadas. O
+ * Quartz vem com o sistema; o que falta instalar é o PyObjC, pelo pip, e isso
+ * este módulo faz sozinho.
+ *
+ * Fora do macOS, ou se o Python/PyObjC não estiverem lá, `disponivel()` diz
+ * que não e o desktop.js segue com o caminho de sempre.
+ */
+
+'use strict';
+
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+const PASTA = path.join(__dirname, '..', 'voz');
+
+let proc = null;          // o processo do cursor, quando de pé
+let pronto = null;        // Promise<boolean> da subida
+let fila = new Map();     // id → { resolve, timer }
+let proximo = 1;
+let semCursor = null;     // motivo, quando não dá para ter cursor nesta máquina
+
+function pythonComQuartz() {
+    let py = null;
+    try { py = require('./voz.js').python(); } catch { /* sem voz.js: sem cursor */ }
+    if (!py) return { py: null };
+    try {
+        execFileSync(py, ['-c', 'import Quartz, AppKit, PyObjCTools'], { stdio: 'ignore', timeout: 20000 });
+        return { py, tem: true };
+    } catch {
+        return { py, tem: false };
+    }
+}
+
+/** Sobe o processo do cursor, instalando o PyObjC se faltar. Uma vez. */
+function subir() {
+    if (pronto) return pronto;
+    pronto = (async () => {
+        if (process.platform !== 'darwin') { semCursor = 'só no macOS'; return false; }
+        let { py, tem } = pythonComQuartz();
+        if (!py) { semCursor = 'sem Python 3'; return false; }
+        if (!tem) {
+            const voz = require('./voz.js');
+            const r = await voz.instalar(py, ['pyobjc-framework-Quartz', 'pyobjc-framework-Cocoa']);
+            if (!r.ok || !pythonComQuartz().tem) { semCursor = `não instalou o PyObjC: ${r.error || ''}`; return false; }
+        }
+        return await new Promise((resolve) => {
+            proc = spawn(py, ['-m', 'primo_voz.cursor'], {
+                cwd: PASTA,
+                env: { ...process.env, PYTHONPATH: PASTA, PYTHONUNBUFFERED: '1' },
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            let buffer = '';
+            let subiu = false;
+            proc.stdout.on('data', (d) => {
+                buffer += d.toString();
+                const linhas = buffer.split('\n');
+                buffer = linhas.pop();
+                for (const linha of linhas) {
+                    let msg;
+                    try { msg = JSON.parse(linha); } catch { continue; }
+                    if (msg.pronto && !subiu) { subiu = true; resolve(true); continue; }
+                    const espera = fila.get(msg.id);
+                    if (espera) { clearTimeout(espera.timer); fila.delete(msg.id); espera.resolve(msg); }
+                }
+            });
+            const morreu = () => {
+                proc = null;
+                pronto = null;           // a próxima ação tenta subir de novo
+                for (const [, e] of fila) { clearTimeout(e.timer); e.resolve({ ok: false, error: 'o cursor fechou' }); }
+                fila = new Map();
+                if (!subiu) { semCursor = 'o processo do cursor não subiu'; resolve(false); }
+            };
+            proc.on('exit', morreu);
+            proc.on('error', morreu);
+            setTimeout(() => { if (!subiu) { semCursor = 'o cursor demorou demais para abrir'; resolve(false); } }, 20000);
+            // O cursor não pode segurar o PrimoCode aberto na saída.
+            proc.unref();
+            proc.stdout.unref && proc.stdout.unref();
+        });
+    })();
+    return pronto;
+}
+
+/** Manda um comando e espera a resposta (a animação inteira, no caso do mouse). */
+async function mandar(cmd, args = {}, tetoMs = 60000) {
+    const ok = await subir();
+    if (!ok || !proc) return { ok: false, semCursor: true, error: semCursor || 'cursor indisponível' };
+    const id = proximo++;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => { fila.delete(id); resolve({ ok: false, error: 'o cursor não respondeu a tempo' }); }, tetoMs);
+        fila.set(id, { resolve, timer });
+        try { proc.stdin.write(JSON.stringify({ id, cmd, ...args }) + '\n'); }
+        catch (e) { clearTimeout(timer); fila.delete(id); resolve({ ok: false, error: e.message }); }
+    });
+}
+
+/** Esta máquina pode ter o cursor do Primo? (sem subir nada) */
+function disponivel() {
+    return process.platform === 'darwin' && process.env.PRIMOCODE_SEM_CURSOR !== '1';
+}
+
+function fechar() {
+    if (proc) { try { proc.stdin.end(); } catch { /* já fechou */ } }
+}
+
+module.exports = { disponivel, mandar, subir, fechar };

package/lib/memoria-conversa.js

@@ -17,10 +17,17 @@
  * 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.
+ * ── RESUMO A CADA MENSAGEM (23/09/2026) ──────────────────────────────────
+ *   "Pra não demorar tanto as respostas, quero que ela gere um resumo a cada
+ *    mensagem, pra daí na próxima mensagem ela ler só esse resumo, não precisa
+ *    ler a conversa inteira."
+ *
+ * Antes, o resumo só nascia quando a conversa passava de ~700 tokens, e as
+ * últimas quatro mensagens iam sempre cruas. Agora TODA resposta é dobrada no
+ * resumo logo depois de terminar (em segundo plano, sem segurar o prompt), e o
+ * pedido seguinte leva só o resumo — mais o que, por falha ou pressa, ainda
+ * não entrou nele. O resumo é que carrega o "de onde parei": ele é instruído a
+ * guardar o último pedido, o que foi feito e o projeto em que se estava.
  *
  * 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.
@@ -34,10 +41,10 @@ function tokensDe(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;
+// Nenhuma mensagem fica de fora do resumo: ele é atualizado a cada rodada.
+const CRUAS = 0;
+// Qualquer coisa nova já vale o resumo — é o que deixa o pedido seguinte leve.
+const LIMITE_TOKENS = 1;
 
 /** Estado inicial — o que o CLI guarda entre um pedido e outro. */
 function nova() {
@@ -103,13 +110,15 @@ function inicioSeguro(todas, alvo) {
  * 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) {
+function paraEnviar(memoria, history, contexto = '') {
     const todas = history || [];
     if (!memoria || !memoria.resumo) return todas.slice(inicioSeguro(todas, todas.length - 20));
 
-    const cruas = todas.slice(inicioSeguro(todas, todas.length - CRUAS));
+    // Só o que ainda NÃO entrou no resumo vai cru — normalmente, nada.
+    const cruas = todas.slice(inicioSeguro(todas, Math.min(memoria.resumidasAte, todas.length)));
+    const extra = contexto ? `\n\n${contexto}` : '';
     return [
-        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}` },
+        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}${extra}` },
         ...cruas,
     ];
 }

package/lib/tools.js

@@ -15,6 +15,29 @@ const os = require('os');
 const { exec, execFile } = require('child_process');
 const browser = require('./browser');
 const desktop = require('./desktop');
+const cursor = require('./cursor');
+
+/* ── O CURSOR DO PRIMO NO MAC ────────────────────────────────────────────
+ * No macOS, mouse e teclado passam pelo cursor dele (lib/cursor.js): a mesma
+ * ação acontece de verdade, e a pessoa VÊ a seta dele indo até lá, clicando,
+ * digitando. Sem o cursor (outro sistema, ou o Python não subiu), vale o
+ * caminho antigo do desktop.js. */
+async function peloCursor(cmd, args, reserva) {
+    if (!cursor.disponivel()) return reserva();
+    const r = await cursor.mandar(cmd, args);
+    if (r.semCursor) return reserva();
+    if (!r.ok) return { ok: false, error: r.error || 'o cursor não conseguiu', ...(r.permissao === false ? { permissao: false } : {}) };
+    return { ok: true };
+}
+
+function numero(v) { const n = Number(v); return Number.isFinite(n) ? n : null; }
+
+async function clicarPeloCursor(x, y, { botao = 'left', duplo = false, rotulo } = {}) {
+    const [nx, ny] = [numero(x), numero(y)];
+    if (nx == null || ny == null) return { ok: false, error: `Coordenada inválida: x=${x}, y=${y}` };
+    return peloCursor('clicar', { x: nx, y: ny, botao: botao === 'right' ? 'direito' : 'esquerdo', duplo, rotulo },
+        () => (duplo ? desktop.doubleClick(nx, ny) : desktop.click(nx, ny, botao)));
+}
 const referencia = require('./referencia');
 const estudio = require('./estudio');
 const cfg = require('./config');
@@ -538,19 +561,46 @@ async function despachar(name, args, ctx) {
                 // resolver dentro do projeto, não do cwd real do processo.
                 return desktop.screenshot(resolveInProject(args.path || `desktop-${Date.now()}.png`, projectDir));
             case 'desktop_click':
-                return desktop.click(args.x, args.y, args.button || 'left');
-            case 'desktop_move':
-                return desktop.move(args.x, args.y);
-            case 'desktop_drag':
-                return desktop.drag(args.from_x, args.from_y, args.to_x, args.to_y);
+                return clicarPeloCursor(args.x, args.y, { botao: args.button || 'left', rotulo: 'clicando' });
+            case 'desktop_move': {
+                const [x, y] = [numero(args.x), numero(args.y)];
+                if (x == null || y == null) return { ok: false, error: `Coordenada inválida: x=${args.x}, y=${args.y}` };
+                return peloCursor('mover', { x, y }, () => desktop.move(x, y));
+            }
+            case 'desktop_drag': {
+                const c4 = [args.from_x, args.from_y, args.to_x, args.to_y].map(numero);
+                if (c4.some((v) => v == null)) return { ok: false, error: 'Coordenada inválida no drag' };
+                return peloCursor('arrastar', { x1: c4[0], y1: c4[1], x2: c4[2], y2: c4[3], rotulo: 'arrastando' },
+                    () => desktop.drag(...c4));
+            }
             case 'desktop_type':
-                return desktop.type(args.text || '');
-            case 'desktop_key':
-                return desktop.key(args.key);
+                return peloCursor('digitar', { texto: args.text || '', rotulo: 'digitando' },
+                    () => desktop.type(args.text || ''));
+            case 'desktop_key': {
+                const r = await peloCursor('tecla', { combo: args.key || '', rotulo: String(args.key || '') },
+                    () => desktop.key(args.key));
+                // Tecla SOLTA que o cursor não conhece: o desktop.js sabe mais
+                // nomes. Combinação com tecla desconhecida ("cmd+xyz") NÃO cai
+                // lá: o osascript digitaria x, y e z com Command apertado —
+                // recortar e desfazer no app da frente.
+                if (!r.ok && /tecla desconhecida/.test(r.error || '') && !String(args.key || '').includes('+')) {
+                    return desktop.key(args.key);
+                }
+                return r;
+            }
             case 'desktop_scroll':
-                return desktop.scroll(args.dy != null ? args.dy : 300);
-            case 'desktop_size':
+                return peloCursor('rolar', { dy: args.dy != null ? Number(args.dy) : 300, rotulo: 'rolando' },
+                    () => desktop.scroll(args.dy != null ? args.dy : 300));
+            case 'desktop_size': {
+                // No Mac, em PONTOS — a mesma unidade dos cliques e das posições
+                // dos botões. O system_profiler dava pixels físicos (2880 num
+                // Retina de 1440), e o clique caía no lugar errado.
+                if (cursor.disponivel()) {
+                    const t = await cursor.mandar('tamanho');
+                    if (t.ok) return { ok: true, width: t.largura, height: t.altura, unidade: 'pontos' };
+                }
                 return desktop.getScreenSize();
+            }
             /* ── O ESTÚDIO ─────────────────────────────────────────────────
              * Sete ferramentas, e nenhuma delas fala com servidor nenhum: o
              * Studio antigo subia um Python em localhost:7777 porque tinha
@@ -583,21 +633,42 @@ async function despachar(name, args, ctx) {
                 return estudio.ferramentaSite(args);
 
             case 'desktop_double_click':
-                return desktop.doubleClick(args.x, args.y);
-            case 'desktop_open_app':
-                return desktop.openApp(args.app || args.name || '');
+                return clicarPeloCursor(args.x, args.y, { duplo: true, rotulo: 'abrindo' });
+            case 'desktop_open_app': {
+                const app = args.app || args.name || '';
+                if (cursor.disponivel()) await cursor.mandar('rotulo', { texto: `abrindo ${app}` });
+                return desktop.openApp(app);
+            }
             case 'desktop_windows':
                 return desktop.listWindows();
             case 'desktop_focus':
                 return desktop.focusWindow(args.window || args.title || '');
             case 'desktop_elements':
                 return desktop.uiElements(args.window);
-            case 'desktop_click_element':
-                return desktop.clickElement(args.name || args.text || '', {
-                    window: args.window,
-                    double: !!args.double,
-                    button: args.button,
+            case 'desktop_click_element': {
+                if (!cursor.disponivel()) {
+                    return desktop.clickElement(args.name || args.text || '', {
+                        window: args.window, double: !!args.double, button: args.button,
+                    });
+                }
+                // Mesma escolha do desktop.clickElement, mas o clique vai pelo
+                // cursor: a pessoa vê a seta ir até o botão pelo nome.
+                const pedido = String(args.name || args.text || '').trim();
+                if (!pedido) return { ok: false, error: 'Diga o nome do elemento (o texto do botão, ícone ou campo).' };
+                const lidos = desktop.uiElements(args.window);
+                if (!lidos.ok) return lidos;
+                const alvo = desktop.escolherElemento(lidos.elementos, pedido);
+                if (!alvo) {
+                    return { ok: false, error: `Nenhum elemento parecido com "${pedido}" na janela "${lidos.janela}".`,
+                        elementosDisponiveis: lidos.elementos.slice(0, 40).map((e) => e.nome),
+                        comoCorrigir: 'Chame de novo com um nome de "elementosDisponiveis", copiado literalmente.' };
+                }
+                const r = await clicarPeloCursor(alvo.x, alvo.y, {
+                    botao: args.button || 'left', duplo: !!args.double, rotulo: `clicando em ${alvo.nome}`.slice(0, 44),
                 });
+                if (!r.ok) return r;
+                return { ok: true, clicado: alvo.nome, tipo: alvo.tipo, x: alvo.x, y: alvo.y, duplo: !!args.double };
+            }
 
             default:
                 /* O MODELO PRECISA CONSEGUIR SE CORRIGIR AQUI.

package/lib/ui.js

@@ -319,6 +319,9 @@ const ROTULOS = {
 function actionHeader(name, args) {
     const label = ROTULOS[name] || name;
     let argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.ferramenta || args.titulo || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || args.arquivo || args.id || JSON.stringify(args).slice(0,60)) : '';
+    // Campo que veio como objeto (o modelo às vezes manda {"window": {}})
+    // virava "[object Object]" na tela.
+    if (argStr && typeof argStr === 'object') argStr = JSON.stringify(argStr).slice(0, 60);
     argStr = String(argStr || '').replace(/\s+/g, ' ').trim();
     // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
     // ao lado do nome — ruído que não diz nada.

package/lib/voz.js

@@ -32,10 +32,23 @@ const { spawn, execFileSync } = require('child_process');
 
 const PASTA = path.join(__dirname, '..', 'voz');
 
+/* ── A DICA DO COMPUTADOR ────────────────────────────────────────────────
+ * Duas razões para existir, e as duas foram medidas:
+ *
+ * 1. O servidor só oferece as ferramentas desktop_* ao modelo quando o pedido
+ *    cita palavras como "mouse", "teclado", "ícone", "atalho", "janela" (o
+ *    grupo "computador" em lib/orcamento-entrada.js do servidor). "Abre o
+ *    Safari e pesquisa X" não cita nenhuma — e o modelo ficava sem as mãos.
+ *    Esta dica as cita de propósito.
+ * 2. "Mostra o teu mouse" virou uma página HTML com as coordenadas do mouse
+ *    DA PESSOA. O certo é mexer o cursor dele, que ela vê na tela.
+ */
+const DICA_COMPUTADOR = `[COMPUTADOR] Você pode usar o mouse, o teclado, as janelas e os ícones do computador da pessoa com as ferramentas desktop_* (desktop_open_app, desktop_click_element, desktop_click, desktop_type, desktop_key para atalho, desktop_scroll). Cada movimento aparece na tela como o SEU cursor. Para abrir um app, use desktop_open_app; para clicar em algo, prefira desktop_click_element pelo nome (leia os nomes com desktop_elements); coordenadas são em pontos da tela (desktop_size). Se pedirem para "mostrar o seu mouse/cursor", MEXA o cursor com desktop_move — nunca crie uma página ou arquivo para isso.`;
+
 /* A instrução de FORMA. Ela não muda o que o agente faz — muda como ele
    conta. O que está proibido aqui é o que não existe em voz: marcador,
    caminho, código, e parágrafo que ninguém segura de ouvido. */
-const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA para a pessoa, e ela não vê tela nenhuma.
+const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. A pessoa está olhando a tela: ela vê o SEU cursor (o mouse e o teclado do computador dela, que você controla) se mexendo em tempo real.
 
 Responda em no máximo 3 frases curtas, em português falado. Nada de lista com
 marcador, nada de caminho de arquivo, nada de bloco de código, nada de
@@ -44,6 +57,8 @@ markdown — nada disso existe no ouvido de alguém.
 Diga o que você FEZ e o que mudou, não como. Se algo deu errado, diga em uma
 frase o que foi e o que você precisa.
 
+${DICA_COMPUTADOR}
+
 Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
 é só o jeito de contar no fim.`;
 
@@ -412,7 +427,10 @@ print(json.dumps(desperta.baixar_modelo()))
 const OPCIONAIS = () => [
     ['faster_whisper', 'faster-whisper', 'a transcrição local (Whisper)'],
     ['vosk', 'vosk', 'o reconhecedor local do "ei, primo"'],
-    ...(process.platform === 'darwin' ? [['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS']] : []),
+    ...(process.platform === 'darwin' ? [
+        ['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS'],
+        ['Quartz', 'pyobjc-framework-Quartz', 'o cursor do Primo na tela'],
+    ] : []),
 ];
 
 function temModulo(py, modulo) {
@@ -556,4 +574,4 @@ async function preparar(aoFalar = () => {}) {
     return { ok: true, python: py, esperando, avisos };
 }
 
-module.exports = { conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+module.exports = { DICA_COMPUTADOR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.5.0",
+  "version": "9.6.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.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/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.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 && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"