primocode 10.4.1 → 10.4.3

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.4.1
+# PrimoCode v10.4.3
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.4.1
+ ▐▛███▜▌   Primo Code v10.4.3
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -305,6 +305,8 @@ function sliderEffort(atual) {
         let anima = null;
 
         const pintar = (primeira) => {
+            // Na tela cheia o slider desenha no painel dela, acima da caixa.
+            if (rl && rl.cheia) return rl.painel(effort.desenharEffort(idx, fase));
             if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
             process.stdout.write(effort.desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
         };
@@ -466,7 +468,7 @@ function barraDeStatus() {
             : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
                 : c.dim(`${uso.pct}% ctx`));
     }
-    direita.push(state.trabalhando
+    direita.push(state.trabalhando && rl && rl.ocupado
         ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
         : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
 
@@ -920,6 +922,7 @@ function abrirMarketplace() {
             const texto = marketplace.montar(estado, {
                 colunas: process.stdout.columns || 80, altura: altura(),
             });
+            if (rl && rl.cheia) return rl.painel(texto);
             const linhas = texto.split('\n');
             // Redesenha POR CIMA do quadro anterior em vez de rolar a tela:
             // sem isso, cada seta empurraria a tela inteira para cima e o
@@ -2760,7 +2763,10 @@ async function main() {
         vazio: ui.convite(),
         telaCheia,
         lateral: barraLateral,
+        logoAnimado: (quadro, trabalhando) => ui.logoAnimado(state.config.mascot, quadro, trabalhando),
+        agora: () => (ui.agora.texto && Date.now() - ui.agora.desde < 10 * 60 * 1000 ? ui.agora.texto : ''),
         versao: VERSION,
+        logo: ui.logoComMascote(state.config.mascot),
         pasta: () => {
             const dir = state.workDir || process.cwd();
             const ramo = ramoDoGit(dir);
@@ -2851,6 +2857,9 @@ async function main() {
             const text = queue.shift().trim();
             if (!text) continue;
             ui.titulo(`⠋ PrimoCode — ${text}`);
+            // Comando (/effort, /help) não é trabalho do agente: a caixa e a
+            // barra da direita só dizem "trabalhando" quando ele trabalha.
+            if (rl.trabalhando) rl.trabalhando(!isSlash(text));
             try {
                 if (ehBash(text)) await rodarBash(text);
                 else if (isSlash(text)) await handleSlash(text);

package/lib/entrada.js

@@ -41,6 +41,7 @@ const readline = require('readline');
 const { EventEmitter } = require('events');
 const { c, visibleWidth, truncate } = require('./ui.js');
 const tela = require('./tela.js');
+const stripAnsiLocal = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
@@ -323,7 +324,6 @@ class Entrada extends EventEmitter {
                e quem põe na tela é o próximo quadro. Suspensa (o painel do
                /effort desenhando por cima), passa direto. */
             if (eu.cheia) {
-                if (eu.suspenso) return eu._stdoutOriginal.call(this, texto, ...resto);
                 tela.acrescentar(eu.conversa, texto);
                 eu._agendar();
                 const fim = resto.find((r) => typeof r === 'function');
@@ -388,13 +388,23 @@ class Entrada extends EventEmitter {
     /* Enquanto outro desenho é dono da tela — o painel do /effort, uma tela
        do marketplace — a caixa sai da frente e larga o teclado. Sem isso, os
        dois desenhariam no mesmo lugar e as setas moveriam os dois. */
-    suspender() { this.suspenso = true; if (this.cheia) this._sairDaTela(); else this._apagar(); }
+    /* Na tela cheia, suspender só LARGA O TECLADO: a tela continua no ar, e
+       quem suspendeu desenha pelo `painel()`. Sair da tela alternativa aqui
+       (o jeito antigo) jogava o /effort por cima do terminal velho, e a
+       volta deixava tudo bagunçado. */
+    suspender() { this.suspenso = true; if (this.cheia) this._agendar(); else this._apagar(); }
     retomar() {
         this.suspenso = false;
-        if (this.cheia && this.ativo && !this.fechado) { this._entrarNaTela(); return this._pintar(); }
+        if (this.cheia && this.ativo && !this.fechado) { this.painelTexto = null; return this._pintar(); }
         if (this.ativo && !this.fechado) this._desenhar();
     }
 
+    /** Um comando com tela própria desenha aqui (na tela cheia). null fecha. */
+    painel(texto) {
+        this.painelTexto = texto == null ? null : String(texto).replace(/\n+$/, '');
+        this._pintar();
+    }
+
     // ── a tela cheia ─────────────────────────────────────────────────────
 
     /* A tela alternativa (a do vim): o que estava no terminal fica guardado e
@@ -412,7 +422,7 @@ class Entrada extends EventEmitter {
             this._colunasReais = process.stdout.columns || 80;
             Object.defineProperty(process.stdout, 'columns', {
                 configurable: true,
-                get() { return eu._naTela && !eu.suspenso ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
+                get() { return eu._naTela ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
                 set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
             });
         }
@@ -440,21 +450,44 @@ class Entrada extends EventEmitter {
     /** O estado do quadro, para a tela cheia (função pura em lib/tela.js). */
     _quadroCheio() {
         const conversa = this.conversa.some((l) => /\S/.test(l));
+        const trabalhando = !!(this.ocupado || this.spinnerTexto);
+        const quadro = Date.now() / 140;
+        /* O topo da barra da direita: o logo do PrimoCode (que anima enquanto
+           ele trabalha) e o ESTADO — trabalhando, há quanto tempo, no quê. */
+        const topo = this.op.logoAnimado ? this.op.logoAnimado(quadro, trabalhando) : [];
+        topo.push('');
+        if (trabalhando) {
+            const giro = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'][Math.floor(quadro) % 10];
+            topo.push(c.warn(giro + ' Trabalhando') + (this._desde ? c.dim(` · ${Math.floor((Date.now() - this._desde) / 1000)}s`) : ''));
+            const agora = this.op.agora ? this.op.agora() : '';
+            if (agora) topo.push(c.muted(agora));
+            if (this.spinnerTexto) topo.push(c.dim(stripAnsiLocal(this.spinnerTexto).replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/, '')));
+        } else {
+            topo.push(c.brand('● ') + c.muted('Pronto') + c.dim(' · esperando você'));
+        }
+        if (trabalhando && !this._animando) {
+            // Enquanto trabalha, a barra se redesenha sozinha (o logo anima
+            // e o relógio anda), mesmo que nada novo chegue na conversa.
+            this._animando = setInterval(() => this._pintar(), 140);
+            if (this._animando.unref) this._animando.unref();
+        } else if (!trabalhando && this._animando) { clearInterval(this._animando); this._animando = null; }
         return tela.quadro({
             colunas: this._colunasReais || 80,
             linhas: process.stdout.rows || 24,
             conversa: this.conversa,
             rolagem: this.rolagem,
-            home: !this.mandou && !conversa,
+            home: !this.mandou && !conversa && !this.painelTexto,
             caixa: (colunas, centro) => montar({ ...this._estado(), colunas, centro, menuAcima: true }),
-            lateral: { titulo: this.titulo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            lateral: { titulo: this.titulo, topo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            painel: this.painelTexto,
             versao: this.op.versao || '',
+            logo: this.op.logo,
             pasta: this.op.pasta ? this.op.pasta() : '',
         });
     }
 
     _pintar() {
-        if (!this.cheia || this.suspenso || this.fechado || !this._naTela) return;
+        if (!this.cheia || this.fechado || !this._naTela) return;
         const q = this._quadroCheio();
         this.rolagem = Math.min(this.rolagem, q.rolagemMax);
         let out = '\x1b[?25l';
@@ -476,6 +509,7 @@ class Entrada extends EventEmitter {
     trabalhando(sim) {
         if (this.ocupado === !!sim) return;
         this.ocupado = !!sim;
+        this._desde = sim ? Date.now() : 0;
         if (this.desenhado) this._redesenhar();
     }
 
@@ -856,7 +890,12 @@ class Entrada extends EventEmitter {
                 const W = this._colunasReais || 80;
                 const mainW = W >= tela.LATERAL_MIN ? W - tela.LATERAL_W : W;
                 this.rolagem = 0;
-                tela.acrescentar(this.conversa, (this.conversa.some((l) => /\S/.test(l)) ? '\n' : '') + pedidoNaTela(visto, mainW - 1) + '\n');
+                /* Uma linha em branco antes e outra depois do pedido: cada
+                   troca (pedido, resposta) é um bloco separado na tela. */
+                const temAlgo = this.conversa.some((l) => /\S/.test(l));
+                const ultima = this.conversa[this.conversa.length - 1] || '';
+                const antes = !temAlgo ? '' : /\S/.test(ultima) ? '\n\n' : '\n';
+                tela.acrescentar(this.conversa, antes + pedidoNaTela(visto, mainW - 1) + '\n\n');
             } else this.escreverCru(pedidoNaTela(visto, process.stdout.columns || 80) + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }

package/lib/tela.js

@@ -33,6 +33,7 @@ const RESET = '\x1b[0m';
 const FUNDO_LATERAL = '\x1b[48;5;234m';
 const LATERAL_W = 42;          // a largura da barra da direita
 const LATERAL_MIN = 110;       // abaixo disso a barra some: a conversa precisa do espaço
+const RECUO = 3;               // quanto a resposta entra em relação ao painel do pedido
 
 /* ── A conversa como texto ───────────────────────────────────────────────
    O que o programa escreve (console.log, o fluxo da resposta) chega aqui
@@ -115,6 +116,8 @@ function caber(s, w, fundo) {
 function lateral(lat, alto) {
     const w = LATERAL_W - 4;           // 2 de margem de cada lado
     const corpo = [''];
+    // O topo: o logo (animado enquanto trabalha) e o estado do Primo agora.
+    if (lat.topo && lat.topo.length) corpo.push(...lat.topo, '');
     for (const l of quebrarComCor(c.bold(c.white(lat.titulo || 'Nova sessão')), w)) corpo.push(l);
     for (const s of (lat.secoes || [])) {
         corpo.push('');
@@ -153,7 +156,7 @@ function quadro(e) {
 
     if (e.home) {
         const caixa = e.caixa(W, true);
-        const lg = W >= 50 ? logo() : [c.bold(c.white('primocode'))];
+        const lg = W >= 60 && e.logo ? e.logo : W >= 50 ? logo() : [c.bold(c.white('primocode'))];
         /* O painel fica PARADO no lugar dele: o menu, quando abre, cobre o
            que está em cima (o logo), em vez de empurrar tudo para cima. */
         const menu = Math.max(0, caixa.linhas.findIndex((l) => l.includes('┃')) - (/┃/.test(caixa.linhas[0]) ? 0 : 0));
@@ -178,6 +181,10 @@ function quadro(e) {
         };
     }
 
+    /* O PAINEL de um comando que desenha a própria tela (o slider do
+       /effort, o marketplace): fica no pé da conversa, logo acima da caixa,
+       por cima do que estiver ali — a tela cheia nunca sai do ar. */
+    const painel = (e.painel ? String(e.painel).split('\n') : []);
     const comLateral = W >= LATERAL_MIN;
     const mainW = comLateral ? W - LATERAL_W : W;
     /* Uma coluna de margem dos dois lados, para a conversa e para a caixa: o
@@ -186,10 +193,18 @@ function quadro(e) {
     const caixa = { ...caixa0, linhas: caixa0.linhas.map((l) => ' ' + l), cursorColuna: caixa0.cursorColuna + 1 };
     const altoConversa = Math.max(1, H - caixa.linhas.length);
 
-    // A conversa, quebrada na largura da coluna, com 2 colunas de margem.
+    /* A conversa, quebrada na largura da coluna. Os PAINÉIS (o pedido que se
+       mandou) ficam na borda da caixa; o resto — a resposta, as ações, o
+       fecho "▣" — entra RECUADO, como no OpenCode. Sem o recuo, tudo saía
+       colado na borda e um bloco não se separava do outro. */
     const visiveis = [];
-    for (const l of (e.conversa || [])) visiveis.push(...quebrarComCor(l, mainW - 2));
+    for (const l of (e.conversa || [])) {
+        const painel = /^(\x1b\[[0-9;]*m)*┃/.test(l);
+        const margem = painel ? ' ' : ' '.repeat(RECUO + 1);
+        for (const p of quebrarComCor(l, painel ? mainW - 2 : mainW - 2 - RECUO)) visiveis.push(margem + p);
+    }
     while (visiveis.length && !temTexto(visiveis[visiveis.length - 1])) visiveis.pop();
+    if (visiveis.length) visiveis.push('');     // um respiro entre a conversa e a caixa
     const rolagemMax = Math.max(0, visiveis.length - altoConversa);
     const rolagem = Math.max(0, Math.min(e.rolagem | 0, rolagemMax));
     const fim = visiveis.length - rolagem;
@@ -197,7 +212,12 @@ function quadro(e) {
     // A conversa encosta EMBAIXO, logo acima da caixa — como num chat.
     const conversa = [];
     for (let i = janela.length; i < altoConversa; i++) conversa.push('');
-    for (const l of janela) conversa.push(' ' + l);
+    for (const l of janela) conversa.push(l);
+    if (painel.length) {
+        const inicio = Math.max(0, conversa.length - painel.length - 1);
+        conversa.splice(inicio, conversa.length - inicio, '', ...painel.map((l) => ' ' + l));
+        conversa.length = altoConversa;
+    }
     if (rolagem > 0) {
         conversa[0] = ' ' + c.dim(`↑ ${rolagem} linha${rolagem > 1 ? 's' : ''} abaixo · PgDn ou a roda do mouse para voltar`);
     }
@@ -217,7 +237,7 @@ function temTexto(l) { return visibleWidth(l) > 0 && /\S/.test(l.replace(/\x1b\[
 /** A largura que o texto da conversa tem, numa tela de `colunas`. */
 function larguraDaConversa(colunas) {
     const W = Math.max(30, colunas || 80);
-    return (W >= LATERAL_MIN ? W - LATERAL_W : W) - 2;
+    return (W >= LATERAL_MIN ? W - LATERAL_W : W) - 2 - RECUO;
 }
 
-module.exports = { larguraDaConversa, quadro, acrescentar, quebrarComCor, lateral, caber, LATERAL_W, LATERAL_MIN };
+module.exports = { RECUO, larguraDaConversa, quadro, acrescentar, quebrarComCor, lateral, caber, LATERAL_W, LATERAL_MIN };

package/lib/ui.js

@@ -358,6 +358,77 @@ function logo() {
 }
 const LOGO_W = visibleWidth(logo()[0]);
 
+/* ── O mascote GRANDE ─────────────────────────────────────────────────
+   O desenho de sempre tem 3 linhas — pequeno ao lado do logo de 4. Para a
+   home ele cresce 2×: cada quarto de bloco (▘ ▝ ▖ ▗) vira um bloco cheio, e
+   cada bloco cheio vira 2×2. Ficam 6 linhas × 18 colunas, com a cor de cada
+   pedaço preservada — o mesmo desenho, não um desenho novo. */
+const QUARTOS = {
+    ' ': [0, 0, 0, 0], '█': [1, 1, 1, 1], '▀': [1, 1, 0, 0], '▄': [0, 0, 1, 1],
+    '▌': [1, 0, 1, 0], '▐': [0, 1, 0, 1], '▘': [1, 0, 0, 0], '▝': [0, 1, 0, 0],
+    '▖': [0, 0, 1, 0], '▗': [0, 0, 0, 1], '▛': [1, 1, 1, 0], '▜': [1, 1, 0, 1],
+    '▙': [1, 0, 1, 1], '▟': [0, 1, 1, 1], '▚': [1, 0, 0, 1], '▞': [0, 1, 1, 0],
+};
+function mascoteGrande(style) {
+    const saida = [];
+    for (const linha of mascot(style)) {
+        // [caractere, cor] de cada coluna da linha colorida
+        const cels = [];
+        let cor = '';
+        for (const m of linha.matchAll(/(\x1b\[[0-9;]*m)|([^\x1b])/gu)) {
+            if (m[1]) { if (m[1] !== PALETTE.reset) cor = m[1]; continue; }
+            cels.push([m[2], cor]);
+        }
+        const cima = [], baixo = [];
+        for (const [ch, cr] of cels) {
+            const q = QUARTOS[ch] || (ch === ' ' ? QUARTOS[' '] : QUARTOS['█']);
+            const bloco = (b) => (b ? `${cr}█${PALETTE.reset}` : ' ');
+            cima.push(bloco(q[0]) + bloco(q[1]));
+            baixo.push(bloco(q[2]) + bloco(q[3]));
+        }
+        saida.push(cima.join(''), baixo.join(''));
+    }
+    while (saida.length && !saida[saida.length - 1].trim()) saida.pop();   // a linha vazia de baixo
+    return saida;
+}
+
+/** O logo da home: o mascote grande e, centrado na altura dele, o letreiro. */
+function logoComMascote(style) {
+    const m = mascoteGrande(style);
+    const l = logo();
+    const desce = Math.floor((m.length - l.length) / 2);
+    const linhas = m.map((linha, i) => linha + '    ' + (l[i - desce] || ''));
+    // Todas com a MESMA largura: a home centraliza linha por linha, e uma
+    // linha mais curta (a dos pés) sairia deslocada do resto do desenho.
+    const larg = Math.max(...linhas.map(visibleWidth));
+    return linhas.map((x) => x + ' '.repeat(larg - visibleWidth(x)));
+}
+
+/* ── O logo animado da barra da direita ──────────────────────────────────
+   Enquanto o Primo trabalha, o mascote pulsa (a cor viva respira entre três
+   tons de ciano), os pés andam, e um brilho corre pelo nome "PrimoCode".
+   Parado, fica quieto: animação sem trabalho é ruído. `quadro` é um número
+   que cresce com o tempo (o chamador passa Date.now()/120). */
+const PULSO = ['\x1b[38;5;45m', '\x1b[38;5;51m', '\x1b[38;5;87m', '\x1b[38;5;51m'];
+function logoAnimado(style, quadro, trabalhando) {
+    const f = Math.floor(quadro || 0);
+    const m = MASCOTS[style] || MASCOTS.primo;
+    // Os pés andam: a linha dos pés troca de passo a cada quadro.
+    const linhas = m.linhas.map((l) => (trabalhando && f % 2 && l === PES ? '  ▝▘ ▘▝  ' : l));
+    let art = linhas.map((l, i) => shade(l, m, m.mascara && m.mascara[i]));
+    if (trabalhando) art = art.map((l) => l.split(PALETTE.brand).join(PULSO[f % PULSO.length]));
+    const nome = 'PrimoCode';
+    const brilho = f % (nome.length + 8);
+    let texto = '';
+    [...nome].forEach((ch, i) => {
+        const base = i < 5 ? '\x1b[38;5;255m' : '\x1b[38;5;45m';
+        const aceso = trabalhando && Math.abs(i - brilho) <= 0;
+        const perto = trabalhando && Math.abs(i - brilho) === 1;
+        texto += (aceso ? '\x1b[1m\x1b[38;5;231m' : perto ? '\x1b[1m\x1b[38;5;159m' : '\x1b[1m' + base) + ch + PALETTE.reset;
+    });
+    return [art[0], art[1] + '  ' + texto, art[2]];
+}
+
 /** Centraliza uma linha (com cor) em `cols` colunas. */
 function centro(s, cols) {
     return ' '.repeat(Math.max(0, Math.floor((cols - visibleWidth(s)) / 2))) + s;
@@ -459,6 +530,8 @@ function titulo(texto) {
     try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
 }
 
+const agora = { texto: '', desde: 0 };
+
 // O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
 const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
@@ -500,6 +573,9 @@ function actionHeader(name, args) {
     // virava "[object Object]" na tela.
     if (argStr && typeof argStr === 'object') argStr = JSON.stringify(argStr).slice(0, 60);
     argStr = String(argStr || '').replace(/\s+/g, ' ').trim();
+    // O que ele está fazendo AGORA — a barra da direita da tela cheia mostra.
+    agora.texto = label + (argStr ? ' · ' + argStr.slice(0, 60) : '');
+    agora.desde = Date.now();
     // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
     // ao lado do nome — ruído que não diz nada.
     if (argStr === '{}' || argStr === 'null' || argStr === 'undefined') argStr = '';
@@ -633,4 +709,4 @@ function friendlyError(raw) {
 
 
 module.exports = {
-    titulo, c, logo, letreiro, convite, EXEMPLOS, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+    titulo, agora, c, logo, logoComMascote, mascoteGrande, logoAnimado, letreiro, convite, EXEMPLOS, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/package.json

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