primocode 10.12.0 → 10.14.0

package/lib/estudio/revisor.js

@@ -16,6 +16,8 @@
  *   avisa     a mesma sequência de elementos em 4+ cenas seguidas (cara de template)
  *   avisa     imagem sem a pessoa pedir, ou imagem em mais da metade das cenas
  *   conserta  efeito sonoro demais (mais de 1 a cada 1,5 s) → ficam os mais altos
+ *   avisa     texto pequeno demais para o celular (< 2% da altura no 9:16)
+ *   avisa     texto com contraste abaixo de 3:1 contra o fundo da cena
  * Puro: o plano entra, o plano consertado e a lista saem.
  */
 
@@ -34,6 +36,62 @@ const palavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
 // Imagem ou vídeo DE FORA: o vídeo da própria gravação (deOrigem) e o recorte da pessoa não contam.
 const imagemDeFora = (el) => el && (el.tipo === 'imagem' || (el.tipo === 'video' && el.deOrigem == null && !/pessoa-/.test(el.src || '')));
 
+/* O TEXTO QUE NÃO SE LÊ (15/10, as referências): rótulo de 1,6% da altura
+   ("NO COADOR") e laranja sobre bege. Nas referências a palavra principal
+   ocupa 55–85% da largura e a segunda voz ~5% da altura, sempre em contraste
+   duro. Contraste é o da WCAG para texto grande (3:1). */
+const hex6 = (c) => {
+    const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(String(c || '').trim());
+    if (!m) return null;
+    const h = m[1].length === 3 ? m[1].split('').map((x) => x + x).join('') : m[1];
+    return [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16) / 255);
+};
+const luminancia = (c) => {
+    const v = hex6(c);
+    if (!v) return null;
+    const [r, g, b] = v.map((x) => (x <= 0.03928 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4)));
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+function contraste(a, b) {
+    const la = luminancia(a), lb = luminancia(b);
+    if (la == null || lb == null) return null;
+    return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+const corDoFundo = (f) => (typeof f === 'string' ? f : f && (f.valor || f.cor)) || null;
+
+function revisarLeitura(plano, avisos) {
+    const W = Number(plano.formato && plano.formato.largura) || 1920, H = Number(plano.formato && plano.formato.altura) || 1080;
+    const piso = H * (W > H ? 0.024 : 0.019);
+    const curto = (t) => String(t || '').slice(0, 24);
+    const pequenos = [], apagados = [];
+    (plano.cenas || []).forEach((c, i) => {
+        const fundo = corDoFundo(c.fundo) || plano.fundoGeral;
+        for (const e of c.elementos || []) {
+            if (!e) continue;
+            if (e.tipo === 'texto') {
+                const tam = Number(e.tamanho || (e.estilo && e.estilo.tamanho));
+                if (tam && tam < piso) pequenos.push(`cena ${i + 1} "${curto(e.texto)}" ${r2((tam / H) * 100)}%`);
+                const k = contraste(e.cor || (e.estilo && e.estilo.cor), fundo);
+                if (k != null && k < 3) apagados.push(`cena ${i + 1} "${curto(e.texto)}" ${r2(k)}:1`);
+            }
+            if (e.tipo === 'kit' && e.peca === 'gerativo' && e.partitura) {
+                const Hp = Number(e.partitura.altura) || H;
+                const pisoP = Hp * ((Number(e.partitura.largura) || W) > Hp ? 0.024 : 0.019);
+                for (const b of e.partitura.batidas || []) {
+                    const cores = b.cores || {};
+                    for (const l of b.linhas || []) {
+                        if (l.tamanho && l.tamanho < pisoP) pequenos.push(`batida ${r2(b.de)}s "${curto(l.texto)}" ${r2((l.tamanho / Hp) * 100)}%`);
+                    }
+                    const k = contraste(cores.texto, cores.fundo);
+                    if (k != null && k < 3) apagados.push(`batida ${r2(b.de)}s ${cores.texto} sobre ${cores.fundo} ${r2(k)}:1`);
+                }
+            }
+        }
+    });
+    if (pequenos.length) avisos.push(`texto pequeno demais para o celular (piso ~2% da altura): ${pequenos.slice(0, 3).join('; ')}${pequenos.length > 3 ? ` e mais ${pequenos.length - 3}` : ''}`);
+    if (apagados.length) avisos.push(`texto com contraste abaixo de 3:1 contra o fundo: ${apagados.slice(0, 3).join('; ')}${apagados.length > 3 ? ` e mais ${apagados.length - 3}` : ''}`);
+}
+
 function revisar(plano, { semImagem = false } = {}) {
     const consertos = [], avisos = [];
     const cenas = (plano && plano.cenas) || [];
@@ -114,6 +172,9 @@ function revisar(plano, { semImagem = false } = {}) {
     if (semImagem && comImagem) avisos.push(`${comImagem} cena(s) com imagem de fora, mas a pessoa não pediu imagem`);
     else if (cenas.length >= 4 && comImagem / cenas.length > 0.5) avisos.push(`imagem em ${comImagem} de ${cenas.length} cenas — a imagem é um momento, não o vídeo inteiro`);
 
+    // 7. O texto que não se lê: pequeno demais ou sem contraste.
+    revisarLeitura(plano, avisos);
+
     return { plano, consertos, avisos };
 }
 

package/lib/estudio/voicestudio.js

@@ -0,0 +1,81 @@
+/**
+ * voicestudio.js — a voz local do VoiceStudio, a primeira da cadeia.
+ *
+ *   "achei isso: https://voicestudio.sh/ podemos usar pra narração do motion,
+ *    ele entra primeiro na cadeia e depois, se falhar, o Gemini" (Joel, 15/10)
+ *
+ * O VoiceStudio é um app de desktop (AGPL-3.0) que a pessoa instala e deixa
+ * aberto; ele serve uma API no formato da OpenAI em localhost:3900, sem chave
+ * no loopback (docs/api-auth.md do repo dele). O PrimoCode só CHAMA a API —
+ * não copia nem distribui o código dele, então a licença não pega.
+ *
+ * Fechado, a porta recusa na hora e a cadeia segue para o Gemini sem esperar.
+ * Puro de rede: http do Node, sem dependência.
+ *
+ *   VOICESTUDIO_URL     outro endereço (padrão http://127.0.0.1:3900)
+ *   VOICESTUDIO_VOZ     o perfil de voz do app (padrão "default")
+ *   VOICESTUDIO_MODELO  o motor (padrão "omnivoice")
+ */
+
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+const URL_PADRAO = 'http://127.0.0.1:3900';
+const LIMITE = 4096;   // o input máximo do /v1/audio/speech
+
+function base(url) { return String(url || process.env.VOICESTUDIO_URL || URL_PADRAO).replace(/\/+$/, ''); }
+
+function pedir(metodo, url, { corpo = null, timeout = 800 } = {}) {
+    return new Promise((ok) => {
+        let u;
+        try { u = new URL(url); } catch { ok({ ok: false, error: 'endereço inválido' }); return; }
+        const lib = u.protocol === 'https:' ? https : http;
+        const dados = corpo ? Buffer.from(JSON.stringify(corpo)) : null;
+        const req = lib.request(u, {
+            method: metodo,
+            headers: dados ? { 'content-type': 'application/json', 'content-length': dados.length } : {},
+        }, (res) => {
+            const partes = [];
+            res.on('data', (c) => partes.push(c));
+            res.on('end', () => ok({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, corpo: Buffer.concat(partes) }));
+        });
+        req.setTimeout(timeout, () => req.destroy(new Error('tempo esgotado')));
+        req.on('error', (e) => ok({ ok: false, error: e.message, recusou: /ECONNREFUSED|EADDRNOTAVAIL|ENOTFOUND/.test(e.code || e.message) }));
+        if (dados) req.write(dados);
+        req.end();
+    });
+}
+
+/** O app está aberto? Pergunta rápida: fechado, a porta recusa na hora. */
+async function disponivel({ url } = {}) {
+    const r = await pedir('GET', base(url) + '/v1/audio/voices', { timeout: 800 });
+    return r.ok === true;
+}
+
+/**
+ * Um texto em áudio (mp3). Nunca lança: devolve {ok, audio} ou {ok:false, error}.
+ * O primeiro pedido carrega o modelo no app, por isso o tempo é longo.
+ */
+async function falar(texto, { url, voz, modelo, idioma = 'pt', timeout = 10 * 60000 } = {}) {
+    const input = String(texto || '').trim();
+    if (!input) return { ok: false, error: 'voicestudio: texto vazio' };
+    if (input.length > LIMITE) return { ok: false, error: `voicestudio: o texto passa de ${LIMITE} caracteres` };
+    if (!(await disponivel({ url }))) return { ok: false, indisponivel: true, error: 'voicestudio: o app não está aberto' };
+    const r = await pedir('POST', base(url) + '/v1/audio/speech', {
+        corpo: {
+            model: modelo || process.env.VOICESTUDIO_MODELO || 'omnivoice',
+            input,
+            voice: voz || process.env.VOICESTUDIO_VOZ || 'default',
+            response_format: 'mp3',
+            language: idioma,
+        },
+        timeout,
+    });
+    if (!r.ok) return { ok: false, error: `voicestudio: ${r.error || 'status ' + r.status}${r.corpo && r.corpo.length < 400 ? ' ' + r.corpo.toString() : ''}` };
+    if (!r.corpo || r.corpo.length < 8) return { ok: false, error: 'voicestudio: áudio vazio' };
+    return { ok: true, audio: r.corpo };
+}
+
+module.exports = { disponivel, falar, URL_PADRAO, LIMITE };

package/lib/headless.js

@@ -0,0 +1,71 @@
+/**
+ * headless.js — `primocode -p "pedido"`: sem tela, para script e CI.
+ *
+ *   primocode -p "arruma o teste"                 texto no stdout
+ *   primocode -p "..." --output-format json       um JSON no fim: {type, is_error, result, duration_ms}
+ *   git diff | primocode -p "revisa isso"         o stdin entra no pedido
+ *   primocode -p "..." --permission-mode plan     só lê (ver lib/perigo.js)
+ *
+ * Mesma ideia do `claude -p` e do `codex exec` (flags documentadas deles; o
+ * código é nosso). O pedido passa pelo MESMO caminho do digitado (sendPrompt).
+ * Código de saída: 0 ok, 1 erro.
+ */
+'use strict';
+
+const { stripAnsi } = require('./ui');
+
+const FORMATOS = ['text', 'json'];
+
+/** Tira -p/--print, --output-format e --permission-mode dos argumentos. */
+function analisar(argv) {
+    const r = { ativo: false, formato: 'text', permissao: null, resto: [], erro: null };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const [chave, valor] = a.startsWith('--') && a.includes('=') ? [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)] : [a, null];
+        if (a === '-p' || a === '--print') r.ativo = true;
+        else if (chave === '--output-format') {
+            const v = valor !== null ? valor : argv[++i];
+            if (!FORMATOS.includes(v)) r.erro = `--output-format aceita ${FORMATOS.join(' ou ')}`;
+            else r.formato = v;
+        } else if (chave === '--permission-mode') r.permissao = valor !== null ? valor : argv[++i];
+        else r.resto.push(a);
+    }
+    return r;
+}
+
+/** O pedido: os argumentos soltos, mais o stdin (que vem depois, como contexto). */
+function montarPedido(palavras, stdin) {
+    const pedido = palavras.join(' ').trim();
+    const extra = String(stdin || '').trim();
+    if (pedido && extra) return `${pedido}\n\n${extra}`;
+    return pedido || extra;
+}
+
+function lerStdin() {
+    if (process.stdin.isTTY) return Promise.resolve('');
+    return new Promise((resolve) => {
+        let s = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (d) => { s += d; });
+        process.stdin.on('end', () => resolve(s));
+        process.stdin.on('error', () => resolve(s));
+    });
+}
+
+/** Roda `fn` guardando tudo o que ela escreve. `calar` esconde da tela. */
+async function capturar(fn, { calar = false } = {}) {
+    const log = console.log;
+    const escrever = process.stdout.write.bind(process.stdout);
+    let texto = '';
+    const pega = (s) => { texto += stripAnsi(s); };
+    console.log = (...a) => { pega(a.join(' ') + '\n'); if (!calar) log(...a); };
+    process.stdout.write = (s, ...resto) => { pega(typeof s === 'string' ? s : Buffer.from(s).toString()); return calar ? true : escrever(s, ...resto); };
+    try { await fn(); } finally { console.log = log; process.stdout.write = escrever; }
+    return texto.replace(/\n{3,}/g, '\n\n').trim();
+}
+
+function resultadoJson({ texto, erro, inicio, permissao }) {
+    return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto' });
+}
+
+module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, FORMATOS };

package/lib/hooks.js

@@ -0,0 +1,72 @@
+/**
+ * hooks.js — comandos seus que rodam ANTES e DEPOIS de cada ferramenta.
+ *
+ * Arquivo: ~/.primocode/hooks.json (vale em tudo) e <projeto>/.primocode/hooks.json:
+ *
+ *   { "PreToolUse":  [{ "matcher": "run_shell|write_file", "command": "./checar.sh" }],
+ *     "PostToolUse": [{ "matcher": "write_file|edit_file", "command": "npx prettier --write ." }] }
+ *
+ * O comando recebe o evento em JSON no stdin ({evento, ferramenta, argumentos,
+ * resultado, pasta}). No PreToolUse, sair com código 2 BLOQUEIA a ferramenta e o
+ * stderr vira o motivo que o agente lê. Qualquer outro código só avisa. Sem
+ * `matcher`, vale para toda ferramenta. O contrato é o mesmo dos hooks
+ * documentados do Claude Code (code.claude.com/docs/en/hooks); o código é nosso.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const EVENTOS = ['PreToolUse', 'PostToolUse'];
+const PRAZO_MS = 10000;
+
+function ler(arquivo) {
+    try {
+        const j = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        return j && typeof j === 'object' ? j : {};
+    } catch { return {}; }
+}
+
+/** Os hooks de um evento: os da casa primeiro, depois os do projeto. */
+function carregar(evento, projectDir) {
+    const arquivos = [path.join(os.homedir(), '.primocode', 'hooks.json')];
+    if (projectDir) arquivos.push(path.join(projectDir, '.primocode', 'hooks.json'));
+    const out = [];
+    for (const a of arquivos) {
+        const lista = ler(a)[evento];
+        if (!Array.isArray(lista)) continue;
+        for (const h of lista) if (h && typeof h.command === 'string' && h.command.trim()) out.push(h);
+    }
+    return out;
+}
+
+function casa(matcher, nome) {
+    if (!matcher || matcher === '*') return true;
+    try { return new RegExp(`^(?:${matcher})$`).test(nome); } catch { return false; }
+}
+
+/**
+ * Roda os hooks do evento. Devolve { bloqueado, motivo, avisos[] }.
+ * Só o PreToolUse bloqueia.
+ */
+function rodar(evento, { nome, args, resultado, projectDir }) {
+    const saida = { bloqueado: false, motivo: '', avisos: [] };
+    if (!EVENTOS.includes(evento)) return saida;
+    const entrada = JSON.stringify({ evento, ferramenta: nome, argumentos: args || {}, resultado, pasta: projectDir });
+    for (const h of carregar(evento, projectDir)) {
+        if (!casa(h.matcher, nome)) continue;
+        const r = spawnSync(h.command, { shell: true, input: entrada, cwd: projectDir || process.cwd(), encoding: 'utf8', timeout: h.timeout ? h.timeout * 1000 : PRAZO_MS });
+        const err = String(r.stderr || '').trim();
+        if (evento === 'PreToolUse' && r.status === 2) {
+            saida.bloqueado = true;
+            saida.motivo = err || `bloqueado pelo hook: ${h.command}`;
+            return saida;
+        }
+        if (r.error || r.status !== 0) saida.avisos.push(`hook "${h.command.slice(0, 40)}" ${r.error ? 'falhou: ' + r.error.message : 'saiu com ' + r.status}${err ? ' — ' + err.slice(0, 120) : ''}`);
+    }
+    return saida;
+}
+
+module.exports = { EVENTOS, carregar, casa, rodar };