primocode 7.17.0 → 7.18.0

package/bin/primocode.js

@@ -119,12 +119,11 @@ function completarSlash(line) {
 // Régua com os níveis, o marcador ▲ embaixo do escolhido, "Faster" à
 // esquerda e "Smarter" à direita. ←/→ move, Enter confirma, Esc cancela.
 
-function desenharEffort(idx) {
+// O layout sai em texto PLANO, com as marcas de onde pintar. Assim os dois
+// pintores (o normal e o do ultracode animado) desenham exatamente a mesma
+// régua — sem duas contas de posição para manter em sincronia.
+function layoutEffort(idx) {
     const cols = Math.max(52, Math.min(process.stdout.columns || 100, 104));
-    const regua = '▔'.repeat(cols);
-    const linhas = [];
-
-    // Cada nível ocupa uma coluna própria; o ultracode fica destacado no fim.
     const rotulos = effort.NOMES;
     const larguras = rotulos.map((n) => Math.max(n.length + 3, 9));
     const posicoes = [];
@@ -134,38 +133,130 @@ function desenharEffort(idx) {
         x += larguras[i];
     }
     const fimRegua = x;
-
-    linhas.push(c.dim(regua));
-    linhas.push('   ' + c.bold(c.white('Effort')));
-    linhas.push('');
-
-    // Faster ....▲.... Smarter — a trilha, com o marcador na posição atual.
     const marca = posicoes[idx];
+
     let trilha = '';
     for (let k = 23; k < fimRegua; k++) {
-        if (k === marca) trilha += c.brand('▲');
-        else if (k === fimRegua - 12) trilha += c.dim('┆');       // ultracode é um degrau à parte
-        else trilha += c.dim(k < marca ? '─' : '─');
+        if (k === marca) trilha += '▲';
+        else if (k === fimRegua - 12) trilha += '┆';   // ultracode é um degrau à parte
+        else trilha += '─';
     }
-    linhas.push('                       ' + c.muted('Faster') + ' '.repeat(Math.max(1, fimRegua - 23 - 6 - 7)) + c.muted('Smarter'));
-    linhas.push('                       ' + trilha);
 
-    // Os nomes, o escolhido aceso.
-    let linhaNomes = ' '.repeat(23);
+    let nomes = ' '.repeat(23);
+    let deNome = 0, ateNome = 0;
     for (let i = 0; i < rotulos.length; i++) {
         const nome = rotulos[i];
-        const espaco = larguras[i];
-        const pad = Math.floor((espaco - nome.length) / 2);
-        const texto = i === idx ? c.bold(c.brand(nome)) : c.muted(nome);
-        linhaNomes += ' '.repeat(pad) + texto + ' '.repeat(espaco - nome.length - pad);
+        const pad = Math.floor((larguras[i] - nome.length) / 2);
+        if (i === idx) { deNome = nomes.length + pad; ateNome = deNome + nome.length; }
+        nomes += ' '.repeat(pad) + nome + ' '.repeat(larguras[i] - nome.length - pad);
     }
-    linhas.push(linhaNomes);
 
     const nivel = effort.nivelDe(rotulos[idx]);
-    linhas.push('                       ' + c.dim(nivel.resumo));
-    linhas.push('');
-    linhas.push('   ' + c.muted('←/→ ajusta · Enter confirma · Esc cancela'));
-    return linhas.join('\n');
+    const vaoExtremos = Math.max(1, fimRegua - 23 - 6 - 7);
+
+    return {
+        cols,
+        marca,
+        destaque: { de: deNome, ate: ateNome },
+        linhas: [
+            { tipo: 'regua',    texto: '▔'.repeat(cols) },
+            { tipo: 'titulo',   texto: '   Effort' },
+            { tipo: 'vazio',    texto: '' },
+            { tipo: 'extremos', texto: ' '.repeat(23) + 'Faster' + ' '.repeat(vaoExtremos) + 'Smarter' },
+            { tipo: 'trilha',   texto: ' '.repeat(23) + trilha },
+            { tipo: 'nomes',    texto: nomes },
+            { tipo: 'resumo',   texto: ' '.repeat(23) + nivel.resumo },
+            { tipo: 'vazio',    texto: '' },
+            { tipo: 'ajuda',    texto: '   ←/→ ajusta · Enter confirma · Esc cancela' },
+        ],
+    };
+}
+
+// ── O brilho do ultracode ────────────────────────────────────────────────
+// No nível máximo o painel inteiro ganha um fundo roxo que ondula, como no
+// Claude Code. São faixas verticais de roxo em brilhos diferentes; a onda
+// anda para o lado a cada quadro, e o texto fica branco por cima.
+//
+// Roxos do cubo de 256 cores, ordenados pelo brilho REAL (luminância), do
+// mais escuro ao mais claro — a onda escolhe um deles por faixa. Fora da
+// lista ficaram os roxos escuros que puxam para o vinho (53-56): quebravam a
+// família violeta. Só 256 cores (não truecolor): funciona em qualquer
+// terminal, inclusive no Terminal.app do macOS.
+const ROXOS = [57, 92, 93, 63, 98, 99, 105, 141];
+
+function fundoRoxo(x, fase) {
+    // Duas ondas de períodos diferentes: o encontro delas dá o desenho
+    // irregular de faixas, em vez de listras repetidas e óbvias.
+    const faixa = Math.floor(x / 2);
+    const onda = Math.sin(faixa * 0.55 + fase) * 0.6 + Math.sin(faixa * 0.17 - fase * 0.7) * 0.4;
+    const i = Math.round((onda + 1) / 2 * (ROXOS.length - 1));
+    return ROXOS[Math.max(0, Math.min(ROXOS.length - 1, i))];
+}
+
+// Pinta a linha inteira (até a largura do painel) com a onda por baixo.
+// `destaque` é o trecho que fica branco e forte (o nível escolhido); o resto
+// da linha sai num lilás claro, para o escolhido saltar aos olhos.
+function pintarLinhaUltra(texto, largura, fase, opts = {}) {
+    const base = opts.base || 231;      // branco
+    const apagado = opts.apagado || base;
+    const destaque = opts.destaque;
+    let saida = '';
+    let corFundo = -1;
+    let corTexto = -1;
+    let forte = null;
+
+    for (let x = 0; x < largura; x++) {
+        const fundo = fundoRoxo(x, fase);
+        if (fundo !== corFundo) { saida += `\x1b[48;5;${fundo}m`; corFundo = fundo; }
+
+        const dentro = destaque && x >= destaque.de && x < destaque.ate;
+        const querForte = opts.negrito || dentro;
+        const querCor = dentro ? base : apagado;
+        if (querForte !== forte) { saida += querForte ? '\x1b[1m' : '\x1b[22m'; forte = querForte; }
+        if (querCor !== corTexto) { saida += `\x1b[38;5;${querCor}m`; corTexto = querCor; }
+
+        saida += texto[x] || ' ';
+    }
+    return saida + '\x1b[0m';
+}
+
+function desenharEffort(idx, fase) {
+    const L = layoutEffort(idx);
+    const ultra = effort.NOMES[idx] === 'ultracode';
+
+    if (ultra) {
+        // No ultracode o painel todo vira fundo animado. Cada linha é pintada
+        // com a MESMA onda, então as faixas ficam alinhadas de cima a baixo.
+        const LILAS = 189;   // lilás bem claro, para o que não é o escolhido
+        return L.linhas.map((l) => {
+            if (l.tipo === 'titulo') return pintarLinhaUltra(l.texto, L.cols, fase, { negrito: true });
+            if (l.tipo === 'nomes') return pintarLinhaUltra(l.texto, L.cols, fase, { destaque: L.destaque, apagado: LILAS });
+            if (l.tipo === 'resumo' || l.tipo === 'extremos') return pintarLinhaUltra(l.texto, L.cols, fase, { base: LILAS, apagado: LILAS });
+            return pintarLinhaUltra(l.texto, L.cols, fase, {});
+        }).join('\n');
+    }
+
+    return L.linhas.map((l) => {
+        const t = l.texto;
+        switch (l.tipo) {
+            case 'regua': return c.dim(t);
+            case 'titulo': return c.bold(c.white(t));
+            case 'extremos': return c.muted(t);
+            case 'trilha': {
+                // O marcador aceso, o resto da trilha recuada.
+                const antes = t.slice(0, L.marca);
+                const depois = t.slice(L.marca + 1);
+                return c.dim(antes) + c.brand('▲') + c.dim(depois);
+            }
+            case 'nomes': {
+                const { de, ate } = L.destaque;
+                return c.muted(t.slice(0, de)) + c.bold(c.brand(t.slice(de, ate))) + c.muted(t.slice(ate));
+            }
+            case 'resumo': return c.dim(t);
+            case 'ajuda': return c.muted(t);
+            default: return t;
+        }
+    }).join('\n');
 }
 
 // Desenha, escuta as setas, e devolve o nome escolhido (ou null se cancelou).
@@ -177,21 +268,38 @@ function sliderEffort(atual) {
         }
         let idx = effort.indiceDe(atual);
         const ALTURA = 9;   // linhas que o desenho ocupa — para redesenhar por cima
+        let fase = 0;
+        let anima = null;
 
         const pintar = (primeira) => {
             if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
-            process.stdout.write(desenharEffort(idx).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
+            process.stdout.write(desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
         };
+
+        // O fundo do ultracode ondula; sair dele apaga a animação na hora, para
+        // não redesenhar sozinho um painel que já está parado.
+        const cuidarDaAnimacao = () => {
+            const ultra = effort.NOMES[idx] === 'ultracode';
+            if (ultra && !anima) {
+                anima = setInterval(() => { fase += 0.32; pintar(false); }, 90);
+                anima.unref();
+            } else if (!ultra && anima) {
+                clearInterval(anima); anima = null;
+            }
+        };
+
         pintar(true);
+        cuidarDaAnimacao();
 
         const aoTeclar = (ch, key) => {
             if (!key) return;
-            if (key.name === 'right' || key.name === 'l') { idx = Math.min(effort.NOMES.length - 1, idx + 1); pintar(false); return; }
-            if (key.name === 'left' || key.name === 'h') { idx = Math.max(0, idx - 1); pintar(false); return; }
+            if (key.name === 'right' || key.name === 'l') { idx = Math.min(effort.NOMES.length - 1, idx + 1); cuidarDaAnimacao(); pintar(false); return; }
+            if (key.name === 'left' || key.name === 'h') { idx = Math.max(0, idx - 1); cuidarDaAnimacao(); pintar(false); return; }
             if (key.name === 'return' || key.name === 'enter') { encerrar(effort.NOMES[idx]); return; }
             if (key.name === 'escape' || (key.ctrl && key.name === 'c')) { encerrar(null); return; }
         };
         const encerrar = (valor) => {
+            if (anima) { clearInterval(anima); anima = null; }
             process.stdin.removeListener('keypress', aoTeclar);
             sliderAtivo = false;
             resolve(valor);

package/package.json

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