primocode 8.16.0 → 8.18.0

package/lib/effort.js

@@ -132,29 +132,100 @@ function layoutEffort(idx) {
 // leem como listras — e listra clara demais apaga o texto branco por cima.
 // O fundo tem de parecer um pano roxo respirando atrás do painel, não uma
 // bandeira. Os tons claros ficam de fora por isso.
-const ROXOS = [54, 55, 56, 57, 57, 93, 93, 99, 98, 92, 56, 55];
+// A rampa do plasma, do fundo frio ao branco quente.
+//
+// Ela é LONGA de propósito: o degradê é desenhado em meia-célula (▀), então
+// há o dobro de linhas para atravessar, e uma rampa curta viraria degrau
+// visível. Começa quase preta e termina em branco — é a amplitude que faz o
+// pico parecer luz, e não só "roxo mais claro".
+// A rampa é a paleta do PrimoCode, não uma cor qualquer.
+//
+// O plasma era roxo — bonito, e de outro programa. A marca do CLI é o ciano
+// (brand 45, o cyan-400 do design system; brandDim 31 é a mesma cor
+// recuando), e é dele que a rampa sai: do teal profundo ao branco, passando
+// exatamente pelo 45 no meio do caminho. Assim o pico da onda é a cor da
+// marca acesa, e não um roxo emprestado.
+const RAMPA = [23, 23, 24, 30, 31, 37, 38, 44, 45, 51, 87, 123, 159, 195, 231];
+
+// Mantido pelo nome antigo porque o resto do arquivo (e o teste) já o
+// conhece; o conteúdo é que mudou de família.
+const ROXOS = RAMPA;
+
+// Quanto o plasma é amortecido nas linhas que têm texto.
+//
+// Baixou de 0.5 para 0.26: "os textos devem ser extremamente legíveis". Com
+// 0.5 a linha ainda chegava ao ciano médio, e ciano claro atrás de texto
+// claro é leitura no limite. Em 0.26 a linha de texto vive no terço escuro
+// da rampa — teal profundo — e o texto branco salta. O brilho não se perde:
+// ele acontece nas faixas abertas, logo acima e abaixo, que é onde ninguém
+// precisa ler.
+const TETO_SOB_TEXTO = 0.26;
+
+// E um teto absoluto, além da escala: por mais alto que o campo suba, atrás
+// de texto ele não passa daqui. A escala sozinha não garante — bastava um
+// pico forte para a linha clarear inteira.
+const INDICE_MAX_TEXTO = 2;     // até o 24 (#005f87): teal fundo, sempre
+//
+// O 2 não foi escolhido a olho. Medi o contraste de TODAS as células de
+// texto ao longo de dezenas de quadros, pela fórmula de luminância relativa
+// da WCAG. Com teto 4 o pior caso dava 4.08 — abaixo do mínimo AA (4.5),
+// e o vilão era o índice 3 (#008787, teal médio) atrás dos traços da régua.
+// Com teto 2 o pior caso passa de 7, que é o nível AAA. O teste refaz essa
+// medida e reprova se algum dia cair.
+
+/* O campo: o que decide a cor de cada meia-célula.
+ *
+ * Três coisas somadas, e é a soma que dá a sensação de energia em vez de
+ * listra:
+ *
+ *   1. uma ONDA DIAGONAL atravessando o painel, devagar;
+ *   2. um PULSO RADIAL saindo do próprio rótulo "ultracode" — é o detalhe
+ *      que amarra a animação ao que ela significa: a potência irradia de
+ *      onde você está;
+ *   3. uma segunda onda lenta, fora de fase, que impede o padrão de se
+ *      repetir de forma óbvia.
+ *
+ * `x` é a coluna, `y` a meia-linha (duas por linha de texto), `foco` a
+ * coluna do rótulo selecionado.
+ */
+function campoUltra(x, y, fase, foco, altura) {
+    // O terminal tem célula alta e estreita: sem corrigir, o pulso radial
+    // sairia como uma elipse achatada em vez de círculo.
+    const dx = (x - foco) * 0.5;
+    const dy = (y - altura / 2) * 1.1;
+    const raio = Math.sqrt(dx * dx + dy * dy);
+
+    const diagonal = Math.sin((x * 0.11) + (y * 0.30) + fase * 1.15);
+    const pulso = Math.sin(raio * 0.42 - fase * 2.1) * Math.exp(-raio * 0.035);
+    const lenta = Math.sin(x * 0.037 - fase * 0.5 + Math.cos(y * 0.19) * 0.8);
+
+    const v = diagonal * 0.42 + pulso * 0.78 + lenta * 0.34;
+    // O divisor maior que a amplitude puxa a média para baixo: o painel fica
+    // a maior parte do tempo em roxo fundo, e o branco vira PICO — evento,
+    // não estado. Centrado, o branco virava o normal e não impressionava
+    // mais nada.
+    return Math.max(0, Math.min(1, (v + 1.15) / 2.75));
+}
+
+// `escala` escurece a linha SEM achatá-la.
+//
+// A primeira versão usava Math.min(v, teto): tudo acima do teto virava a
+// mesma cor, e as linhas de texto ganhavam platôs chapados — retângulos
+// visíveis atravessando o plasma. Multiplicar preserva a forma da onda e só
+// baixa a amplitude: a linha fica escura o bastante para ler e continua
+// fazendo parte do mesmo pano.
+function corDoCampo(v, escala, tetoIndice) {
+    const t = escala ? v * escala : v;
+    let i = Math.round(t * (RAMPA.length - 1));
+    if (tetoIndice != null) i = Math.min(i, tetoIndice);
+    return RAMPA[Math.max(0, Math.min(RAMPA.length - 1, i))];
+}
 
+// Guardada para quem já usava a onda antiga (e para o teste da rampa).
 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.
-    //
-    // As frequências caíram (0.55 → 0.13) porque as faixas tinham três
-    // colunas de largura: de longe aquilo não era um fundo ondulando, era
-    // chuviscado. Faixa larga anda devagar pela tela, que é o movimento que
-    // se quer ver — o painel respira em vez de piscar.
-    const faixa = x / 2;
-    const onda = Math.sin(faixa * 0.13 + fase) * 0.62 + Math.sin(faixa * 0.041 - fase * 0.55) * 0.38;
-    // A curva ³ empurra os valores para o MEIO da rampa: os extremos (o mais
-    // escuro e o mais claro) só aparecem no pico da onda, e o painel passa a
-    // maior parte do tempo num roxo médio, onde o texto branco se lê.
-    const suave = Math.pow(onda, 3) * 0.55 + onda * 0.45;
-    const i = Math.round((suave + 1) / 2 * (ROXOS.length - 1));
-    return ROXOS[Math.max(0, Math.min(ROXOS.length - 1, i))];
+    return corDoCampo(campoUltra(x, 0, fase, 0, 2));
 }
 
-// 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;
@@ -179,25 +250,98 @@ function pintarLinhaUltra(texto, largura, fase, opts = {}) {
     return saida + '\x1b[0m';
 }
 
+/* O painel do ultracode, desenhado em MEIA-CÉLULA.
+ *
+ * O caractere "▀" ocupa a metade de cima da célula. Pintando a frente dele
+ * com uma cor e o fundo com outra, cada linha do terminal carrega DUAS
+ * linhas de imagem. É o que separa um degradê em blocos de um degradê que
+ * parece luz — e é como demo de terminal sempre fez.
+ *
+ * Onde há letra, a célula deixa de ser meia e vira fundo liso: não dá para
+ * ter o glifo do texto e o do meio-bloco na mesma célula. Aí o fundo é a
+ * média das duas metades, limitada para o texto continuar legível.
+ */
+function painelUltra(L, fase) {
+    const alturaMeia = L.linhas.length * 2;
+    const foco = (L.destaque.de + L.destaque.ate) / 2;
+    // Duas cores de texto, as duas claras. Sobre o teal escuro das linhas de
+    // texto, tanto o branco quanto o ciano-claro passam com folga — e a
+    // diferença entre eles ainda separa o que está escolhido do resto.
+    //
+    // O lilás de antes (189) não era da paleta e, sobre ciano, ficava sujo.
+    // TUDO branco. A hierarquia fica no negrito, não na cor.
+    //
+    // O secundário era 195 (ciano quase branco). Bonito, e o cálculo de
+    // contraste reprovou: sobre o teal mais claro que o fundo de texto pode
+    // ter, o 195 dá 6.57 — passa o mínimo AA (4.5) e não chega ao AAA (7.0).
+    // E não adiantava clarear um pouco: sobre aquele fundo, NENHUMA cor
+    // chega a 7 a não ser o branco puro, que dá 7.20. Como o pedido foi
+    // "extremamente legíveis", o branco ganhou e a diferença entre escolhido
+    // e resto passou a ser o peso da fonte — que separa igual e não custa
+    // contraste nenhum.
+    const BRANCO = 231;
+    const CLARO = 231;
+
+    const corDoTexto = (l, x) => {
+        if (l.tipo === 'titulo') return { cor: BRANCO, negrito: true };
+        if (l.tipo === 'nomes') {
+            const dentro = x >= L.destaque.de && x < L.destaque.ate;
+            return { cor: dentro ? BRANCO : CLARO, negrito: dentro };
+        }
+        return { cor: CLARO, negrito: false };
+    };
+
+    return L.linhas.map((l, y) => {
+        // A régua "▔" some no ultra: sobre o plasma ela virava uma listra
+        // clara cortando o topo do bloco.
+        const texto = l.tipo === 'regua' ? '' : l.texto;
+        // Linha COM texto é acalmada inteira, não só debaixo das letras.
+        //
+        // Limitar só a célula do glifo não bastava: o vão entre as palavras
+        // recebia o plasma cheio, e um pico branco encostado na letra some
+        // com ela do mesmo jeito. A linha toda vira superfície escura, e o
+        // brilho fica para as faixas abertas — que é onde ele aparece sem
+        // atrapalhar ninguém.
+        const linhaCalma = texto.trim().length > 0 ? TETO_SOB_TEXTO : 0;
+        let saida = '';
+        let fg = -1, bg = -1, forte = null;
+
+        for (let x = 0; x < L.cols; x++) {
+            const ch = texto[x] || ' ';
+            const temLetra = ch !== ' ';
+            const cima = campoUltra(x, y * 2, fase, foco, alturaMeia);
+            const baixo = campoUltra(x, y * 2 + 1, fase, foco, alturaMeia);
+
+            let glifo, corFrente, corFundo, querForte;
+            if (temLetra) {
+                const t = corDoTexto(l, x);
+                glifo = ch;
+                corFrente = t.cor;
+                querForte = t.negrito;
+                corFundo = corDoCampo((cima + baixo) / 2, TETO_SOB_TEXTO, INDICE_MAX_TEXTO);
+            } else {
+                glifo = '▀';                 // ▀
+                const teto = linhaCalma ? INDICE_MAX_TEXTO : null;
+                corFrente = corDoCampo(cima, linhaCalma, teto);
+                corFundo = corDoCampo(baixo, linhaCalma, teto);
+                querForte = false;
+            }
+
+            if (corFundo !== bg) { saida += `\x1b[48;5;${corFundo}m`; bg = corFundo; }
+            if (corFrente !== fg) { saida += `\x1b[38;5;${corFrente}m`; fg = corFrente; }
+            if (querForte !== forte) { saida += querForte ? '\x1b[1m' : '\x1b[22m'; forte = querForte; }
+            saida += glifo;
+        }
+        return saida + '\x1b[0m';
+    }).join('\n');
+}
+
 function desenharEffort(idx, fase) {
     const L = layoutEffort(idx);
     const ultra = 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) => {
-            // A régua é uma fileira de "▔". Sobre o roxo ela virava uma
-            // listra clara atravessando o topo e cortava o bloco em dois.
-            // No ultra ela some e vira fundo liso: a borda de cima do painel
-            // passa a ser o próprio degradê, que é o que se quer ver.
-            if (l.tipo === 'regua') return pintarLinhaUltra('', L.cols, fase, {});
-            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 painelUltra(L, fase);
     }
 
     return L.linhas.map((l) => {
@@ -224,5 +368,6 @@ function desenharEffort(idx, fase) {
 }
 
 module.exports = { NIVEIS, NOMES, normalizar, nivelDe, indiceDe, modeloDe, pesquisaDe,
-    layoutEffort, fundoRoxo, pintarLinhaUltra, desenharEffort, ROXOS };
+    layoutEffort, fundoRoxo, pintarLinhaUltra, desenharEffort, ROXOS, RAMPA,
+    campoUltra, corDoCampo, painelUltra };
 

package/package.json

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