primocode 8.42.2 → 9.0.0

package/lib/diff.js

@@ -0,0 +1,161 @@
+/**
+ * diff.js — o que mudou no arquivo, linha a linha.
+ *
+ * ── POR QUE ISTO EXISTE ──────────────────────────────────────────────────
+ * O que a tela dizia quando o agente editava um arquivo era isto:
+ *
+ *     ● Edit  src/app.js
+ *       ⎿ 2 trocas · +7 linhas
+ *
+ * Sete linhas a mais. Quais? A única forma de saber era abrir o arquivo
+ * depois — ou seja, o agente mexia no seu código e você via um número. É a
+ * diferença entre acompanhar e torcer.
+ *
+ * ── POR QUE NÃO UMA BIBLIOTECA ───────────────────────────────────────────
+ * O PrimoCode não tem dependência nenhuma, e é isso que faz o `npm i -g`
+ * terminar em segundos. Um diff de linhas é um algoritmo de uma tela, e está
+ * escrito aqui embaixo.
+ *
+ * ── O DIFF NÃO VAI PARA O MODELO ─────────────────────────────────────────
+ * Ele é desenhado para a PESSOA. Mandá-lo de volta ao modelo dentro do
+ * resultado da tool custaria centenas de tokens por edição, num plano que é
+ * limitado por token — e o modelo acabou de escrever aquele texto, então não
+ * aprende nada relendo. Por isso quem chama guarda o desenho numa chave com
+ * `_` na frente, que o act.js tira antes de a conversa seguir.
+ */
+
+'use strict';
+
+const { c } = require('./ui.js');
+
+/* Arquivo grande não ganha diff desenhado, ganha o resumo em números.
+ *
+ * O motivo não é o custo do algoritmo: é a tela. Um diff de 400 linhas
+ * empurra para fora da vista tudo o que veio antes — inclusive o pedido da
+ * pessoa e os passos anteriores. Um bloco que esconde o resto da conversa é
+ * pior que um número. */
+const MAX_LINHAS_ARQUIVO = 1200;
+/* E há um segundo teto, este por memória: a tabela do LCS é uma matriz
+   (linhasA+1) × (linhasB+1) de inteiros. Com 1200 × 1200 são ~5,8 MB, o que
+   é barato. O produto é o que importa, não cada lado: 1200 linhas contra 20
+   é trivial, 1200 contra 1200 é o pior caso. */
+const MAX_CELULAS = 1200 * 1200;
+const CONTEXTO = 2;        // linhas iguais mostradas em volta de cada mudança
+const MAX_MOSTRADAS = 24;  // teto do bloco inteiro, contando as de contexto
+
+/**
+ * O diff de duas versões de um texto, como lista de operações.
+ *
+ * Algoritmo: maior subsequência comum de LINHAS, em programação dinâmica.
+ * É O(n×m) em tempo e memória, o que é perfeitamente aceitável até alguns
+ * milhares de linhas — e acima disso o desenho nem sai (ver acima).
+ *
+ * @returns {Array<{tipo:' '|'+'|'-', texto:string, a:number, b:number}>}
+ *          `a` é a linha no ANTES, `b` no DEPOIS (1-based, 0 quando não existe).
+ */
+function operacoes(antes, depois) {
+    const A = String(antes ?? '').split('\n');
+    const B = String(depois ?? '').split('\n');
+
+    // A tabela do LCS: lcs[i][j] = tamanho da maior subsequência comum entre
+    // A[i..] e B[j..]. Construída de trás para frente para a leitura sair na
+    // ordem natural depois.
+    const lcs = Array.from({ length: A.length + 1 }, () => new Uint32Array(B.length + 1));
+    for (let i = A.length - 1; i >= 0; i--) {
+        for (let j = B.length - 1; j >= 0; j--) {
+            lcs[i][j] = A[i] === B[j]
+                ? lcs[i + 1][j + 1] + 1
+                : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+
+    const ops = [];
+    let i = 0, j = 0;
+    while (i < A.length && j < B.length) {
+        if (A[i] === B[j]) { ops.push({ tipo: ' ', texto: A[i], a: i + 1, b: j + 1 }); i++; j++; }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) { ops.push({ tipo: '-', texto: A[i], a: i + 1, b: 0 }); i++; }
+        else { ops.push({ tipo: '+', texto: B[j], a: 0, b: j + 1 }); j++; }
+    }
+    while (i < A.length) { ops.push({ tipo: '-', texto: A[i], a: i + 1, b: 0 }); i++; }
+    while (j < B.length) { ops.push({ tipo: '+', texto: B[j], a: 0, b: j + 1 }); j++; }
+    return ops;
+}
+
+/** Quantas linhas entraram e quantas saíram. */
+function contar(ops) {
+    let mais = 0, menos = 0;
+    for (const o of ops) { if (o.tipo === '+') mais++; else if (o.tipo === '-') menos++; }
+    return { mais, menos };
+}
+
+/**
+ * Só os pedaços que interessam: cada mudança com algumas linhas iguais em
+ * volta. O resto do arquivo não entra — num arquivo de 500 linhas com uma
+ * troca, mostrar as 500 é esconder a troca.
+ */
+function pedacos(ops, contexto = CONTEXTO) {
+    const querida = new Array(ops.length).fill(false);
+    ops.forEach((o, k) => {
+        if (o.tipo === ' ') return;
+        for (let x = Math.max(0, k - contexto); x <= Math.min(ops.length - 1, k + contexto); x++) querida[x] = true;
+    });
+
+    const blocos = [];
+    let atual = null;
+    for (let k = 0; k < ops.length; k++) {
+        if (!querida[k]) { atual = null; continue; }
+        if (!atual) { atual = []; blocos.push(atual); }
+        atual.push(ops[k]);
+    }
+    return blocos;
+}
+
+/**
+ * O bloco de diff pronto para a tela.
+ *
+ * @param {string} antes
+ * @param {string} depois
+ * @param {object} op
+ * @param {string} op.prefixo   o recuo de cada linha (vem do fala.resultado)
+ * @param {number} op.max       teto de linhas desenhadas
+ * @returns {string} '' quando não vale a pena desenhar
+ */
+function desenhar(antes, depois, { prefixo = '', max = MAX_MOSTRADAS } = {}) {
+    const linhasA = String(antes ?? '').split('\n').length;
+    const linhasB = String(depois ?? '').split('\n').length;
+    if (Math.max(linhasA, linhasB) > MAX_LINHAS_ARQUIVO) return '';
+    if (linhasA * linhasB > MAX_CELULAS) return '';
+    if (antes === depois) return '';
+
+    const ops = operacoes(antes, depois);
+    const blocos = pedacos(ops);
+    if (!blocos.length) return '';
+
+    const out = [];
+    let desenhadas = 0;
+    let cortou = false;
+
+    for (const bloco of blocos) {
+        if (desenhadas >= max) { cortou = true; break; }
+        for (const o of bloco) {
+            if (desenhadas >= max) { cortou = true; break; }
+            // O número da linha é o do DEPOIS quando a linha existe lá; nas
+            // removidas, o do antes. Sem número, "+ const x = 1" não diz onde.
+            const n = String(o.b || o.a || '').padStart(4);
+            const texto = o.texto.length > 120 ? o.texto.slice(0, 119) + '…' : o.texto;
+            if (o.tipo === '+') out.push(prefixo + c.dim(n) + ' ' + c.ok('+ ' + texto));
+            else if (o.tipo === '-') out.push(prefixo + c.dim(n) + ' ' + c.err('- ' + texto));
+            else out.push(prefixo + c.dim(n) + ' ' + c.dim('  ' + texto));
+            desenhadas++;
+        }
+    }
+
+    if (cortou) {
+        const { mais, menos } = contar(ops);
+        out.push(prefixo + c.dim(`… o bloco continua — ${mais} linha${mais === 1 ? '' : 's'} a mais `
+            + `e ${menos} a menos, no total`));
+    }
+    return out.join('\n');
+}
+
+module.exports = { operacoes, contar, pedacos, desenhar, MAX_LINHAS_ARQUIVO, MAX_CELULAS, MAX_MOSTRADAS };

package/lib/diretor.js

@@ -23,11 +23,19 @@
  * diretor com o defeito apontado — uma vez. Aceitar "quase certo" aqui custa
  * um vídeo de 40 segundos que dura 12.
  *
- * ── O MOTOR NÃO É GOSTO ──────────────────────────────────────────────────
- * Estúdio ou Remotion: a escolha tem regra (`motorPara`), porque a resposta
- * errada aparece tarde — no vídeo de três minutos que engasgou na gravação do
- * navegador, ou nos cinco minutos de `npm install` para fazer um story de
- * 15 segundos.
+ * ── O QUE O DIRETOR NÃO ESCOLHE MAIS ─────────────────────────────────────
+ * Ele escolhia o MOTOR (estúdio ou Remotion) e o TEMA, o LAYOUT e o FUNDO,
+ * cada um numa lista fechada — "meia-noite | claro | papel | neon", "capa |
+ * titulo | secao | duas-colunas". Motor não existe mais: o Remotion é o
+ * único renderizador. E as outras três listas saíram por decisão do produto:
+ *
+ *   "tira os templates e os estilos prontos, eles deixam a IA preguiçosa e
+ *    todo vídeo sai igual e genérico"
+ *
+ * Uma lista de seis temas é um template com outro nome — o modelo escolhe um
+ * dos seis e para de pensar em cor. No lugar delas o diretor DESCREVE: que
+ * paleta, que ar, o que está na tela, como a cena troca. Descrição não tem
+ * seis opções, e é o produtor quem compõe aquilo com os primitivos.
  */
 
 'use strict';
@@ -56,32 +64,6 @@ function precisaDeProducao(texto) {
 
 // ── 2. as decisões que não são do modelo ─────────────────────────────────
 
-/**
- * Estúdio ou Remotion.
- *
- * O estúdio exporta em segundos e não instala nada: é o padrão, e para story,
- * reels e teaser é a resposta certa. Remotion custa um `npm install` de
- * minutos e meio giga, e devolve o que o estúdio não tem: quadro a quadro
- * determinístico, vídeo longo sem risco de engasgo, canal alfa e ProRes.
- */
-function motorPara({ segundos = 0, pedido = '', alfa = false, fps = 30, entrega } = {}) {
-    const t = String(pedido).toLowerCase();
-    if (/remotion/.test(t)) return { motor: 'remotion', motivo: 'foi pedido pelo nome' };
-    if (/(est[uú]dio|studio|r[aá]pido|agora|j[aá])\b/.test(t) && segundos <= 60) {
-        return { motor: 'estudio', motivo: 'pedido rápido e curto' };
-    }
-    if (alfa || /alfa|transpar[eê]nci|prores|canal alfa/.test(t)) {
-        return { motor: 'remotion', motivo: 'canal alfa e ProRes só existem no Remotion' };
-    }
-    if (entrega === 'cinema' || fps > 30) {
-        return { motor: 'remotion', motivo: 'fps alto pede render determinístico' };
-    }
-    if (segundos > 90) {
-        return { motor: 'remotion', motivo: 'vídeo longo: a gravação do navegador engasga' };
-    }
-    return { motor: 'estudio', motivo: 'curto: sai em segundos, sem instalar nada' };
-}
-
 /**
  * A voz. Tom e idioma decidem; o nome exato quem resolve é o estúdio, que
  * sabe o que está instalado — aqui sai a INTENÇÃO, que é o que o diretor
@@ -115,7 +97,7 @@ function ritmoPara(segundos) {
 
 // ── 3. o plano ───────────────────────────────────────────────────────────
 
-const CAMPOS_CENA = ['titulo', 'narracao', 'duracao', 'layout', 'fundo', 'transicao',
+const CAMPOS_CENA = ['titulo', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
     'elementos', 'midia', 'camera', 'chaves', 'notas'];
 
 /**
@@ -132,16 +114,21 @@ function normalizarPlano(bruto, { segundos } = {}) {
     const cenas = Array.isArray(p.cenas) ? p.cenas : [];
     if (!cenas.length) defeitos.push('o plano veio sem cenas');
 
-    const TRANSICOES = ['corte', 'fade', 'deslizar', 'subir', 'zoom', 'limpar', 'persiana', 'flash'];
     const limpas = cenas.map((c, i) => {
         const cena = {};
         for (const k of CAMPOS_CENA) if (c && c[k] !== undefined) cena[k] = c[k];
         cena.duracao = Math.max(1.2, Math.min(15, Number(cena.duracao) || 3.5));
         cena.narracao = typeof cena.narracao === 'string' ? cena.narracao.trim() : '';
         if (!cena.narracao) defeitos.push(`cena ${i + 1} sem narração`);
-        if (!cena.titulo && !cena.elementos) defeitos.push(`cena ${i + 1} sem nada na tela`);
-        // Tudo em fade parece slide, não vídeo — e o diretor esquece disso.
-        if (!TRANSICOES.includes(cena.transicao)) cena.transicao = i === 0 ? 'fade' : TRANSICOES[(i % 6) + 1];
+        if (!cena.titulo && !cena.aTela && !cena.elementos) defeitos.push(`cena ${i + 1} sem nada na tela`);
+        /* A transição é texto: "o logo desce e o fundo abre com ele", não um
+           item de lista. O rodízio que havia aqui (fade, deslizar, subir…
+           em ordem) escondia o defeito em vez de apontá-lo: preenchia a
+           lacuna com a próxima palavra da fila, e o vídeo saía com oito
+           transições que ninguém escolheu. Cena sem transição é DEFEITO, e
+           volta para o diretor decidir. */
+        cena.transicao = typeof cena.transicao === 'string' ? cena.transicao.trim() : '';
+        if (!cena.transicao) defeitos.push(`cena ${i + 1} não diz como entra`);
         cena.midia = Array.isArray(cena.midia) ? cena.midia.filter((m) => m && m.busca) : [];
         return cena;
     });
@@ -153,11 +140,13 @@ function normalizarPlano(bruto, { segundos } = {}) {
     const fecha = !alvo || Math.abs(total - alvo) <= Math.max(3, alvo * 0.2);
     if (!fecha) defeitos.push(`a soma das cenas dá ${total}s e o pedido é ${alvo}s`);
 
+    if (!String(p.visual || '').trim()) defeitos.push('o plano não diz a direção de arte (visual): paleta, ar e tipografia');
+
     const plano = {
         titulo: String(p.titulo || '').trim() || 'Sem título',
         formato: p.formato === 'apresentacao' ? 'apresentacao' : 'video',
         proporcao: ['16:9', '9:16', '1:1', '4:5'].includes(p.proporcao) ? p.proporcao : '16:9',
-        tema: p.tema || 'meia-noite',
+        visual: String(p.visual || '').trim() || null,
         tom: p.tom || 'neutro',
         publico: p.publico || null,
         promessa: p.promessa || null,          // o que a pessoa leva do vídeo
@@ -172,8 +161,6 @@ function normalizarPlano(bruto, { segundos } = {}) {
         midia: limpas.flatMap((c, i) => c.midia.map((m) => ({ cena: i + 1, ...m }))),
         creditos: !!p.creditos,
     };
-    plano.motor = motorPara({ segundos: total, pedido: p.pedido || '', alfa: !!p.alfa,
-        fps: Number(p.fps) || 30 });
     return { plano, defeitos, ok: defeitos.length === 0 };
 }
 
@@ -192,7 +179,7 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
   "titulo": "…",
   "formato": "${formato}",
   "proporcao": "16:9 | 9:16 | 1:1 | 4:5",
-  "tema": "meia-noite | claro | papel | neon | brasa | floresta",
+  "visual": "a direção de arte em uma ou duas frases: paleta (diga as cores em hex), que ar tem (limpo, denso, luminoso, sujo), que tipografia pede. NÃO existe lista de temas — descreva o que este vídeo tem de próprio.",
   "tom": "como deve soar (institucional, urgente, documental, leve…)",
   "publico": "para quem é",
   "promessa": "o que a pessoa leva ao terminar de ver",
@@ -202,9 +189,9 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
       "titulo": "o que aparece grande na tela",
       "narracao": "a frase FALADA, escrita para ser lida em voz alta",
       "duracao": 3.5,
-      "layout": "capa | titulo | secao | duas-colunas | numeros | citacao | imagem-direita | centro | livre",
-      "fundo": "malha | aurora | raios | ondas | nevoa | vinheta, uma cor, ou {\\"imagem\\":\\"<da lista midia>\\"}",
-      "transicao": "corte | fade | deslizar | subir | zoom | limpar | persiana | flash",
+      "aTela": "o que se vê nesta cena, descrito como você descreveria para um motion designer: onde está cada coisa, que tamanho tem, o que domina o quadro",
+      "fundo": "o fundo desta cena — uma cor, um gradiente (diga as cores), uma imagem da lista midia, ou o que ele vira no meio da cena",
+      "transicao": "como esta cena ENTRA, descrito: o que se move, em que direção, quanto dura. Corte seco também é resposta — diga 'corte'.",
       "midia": [ { "busca": "o que procurar", "tipo": "imagem | logo", "papel": "fundo | destaque | selo", "semFundo": false } ],
       "camera": "aproximar | afastar | pan-direita | pan-esquerda | subir | descer | empurrar | balanco | nenhuma",
       "chaves": "descreva em uma frase o movimento principal desta cena (o que entra, o que atravessa, o que cresce)",
@@ -219,6 +206,7 @@ REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
 3. ARCO. Primeira cena prende em 2 segundos, o miolo entrega, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
 4. NÚMERO É CONCRETO. Nada de "muitos clientes": ou tem o número, ou a frase muda.
 5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
+5b. NADA DE GAVETA. Não existe tema pronto, layout pronto nem fundo pronto: é você que decide a cor, a tipografia e a composição DESTE vídeo. Dois vídeos seus sobre assuntos diferentes não podem sair parecidos.
 6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
 7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
 8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".`;
@@ -279,16 +267,18 @@ function pauta(plano) {
     const p = plano || {};
     const linhas = [];
     linhas.push(`PLANO DE PRODUÇÃO — ${p.titulo}`);
-    linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tema ${p.tema} · tom ${p.tom}`);
-    linhas.push(`motor: ${p.motor && p.motor.motor} (${p.motor && p.motor.motivo})`);
+    linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tom ${p.tom}`);
+    if (p.visual) linhas.push(`visual: ${p.visual}`);
     if (p.promessa) linhas.push(`promessa: ${p.promessa}`);
     if (p.publico) linhas.push(`público: ${p.publico}`);
     linhas.push(`voz: ${p.voz && p.voz.perfil} · ${p.voz && p.voz.instrucao} · ${p.voz && p.voz.idioma}`);
     if (p.trilha) linhas.push(`trilha: ${p.trilha.busca || p.trilha.arquivo} (volume ${p.trilha.volume})`);
     linhas.push('');
     (p.cenas || []).forEach((c, i) => {
-        linhas.push(`CENA ${i + 1} — ${c.duracao}s · layout ${c.layout || 'titulo'} · entra em ${c.transicao}`);
+        linhas.push(`CENA ${i + 1} — ${c.duracao}s · entra: ${c.transicao}`);
         if (c.titulo) linhas.push(`  na tela: ${c.titulo}`);
+        if (c.aTela) linhas.push(`  composição: ${c.aTela}`);
+        if (c.fundo) linhas.push(`  fundo: ${typeof c.fundo === 'string' ? c.fundo : JSON.stringify(c.fundo)}`);
         linhas.push(`  narração: ${c.narracao}`);
         if (c.camera && c.camera !== 'nenhuma') linhas.push(`  câmera: ${c.camera}`);
         if (c.chaves) linhas.push(`  movimento: ${c.chaves}`);
@@ -303,7 +293,7 @@ function pauta(plano) {
 }
 
 module.exports = {
-    precisaDeProducao, motorPara, vozPara, ritmoPara,
+    precisaDeProducao, vozPara, ritmoPara,
     normalizarPlano, extrairJSON, planejar, pauta,
     DIRETOR, REVISAO,
 };