primocode 10.12.0 → 10.14.0

package/lib/estudio/index.js

@@ -48,6 +48,7 @@ const video = require('./video.js');
 const batida = require('./batida.js');
 const revisor = require('./revisor.js');
 const marcaLib = require('./marca.js');
+const marcaKit = require('../marca-kit.js');
 const conferencia = require('./conferencia.js');
 const margem = require('./margem.js');
 const assinatura = require('./assinatura.js');
@@ -65,6 +66,7 @@ const gerativo = require('./gerativo.js');
 const fluido = require('./fluido.js');
 const vox = require('./vox.js');
 const kokoro = require('./kokoro.js');
+const voicestudio = require('./voicestudio.js');
 const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
 const personagem = require('./personagem.js');
@@ -361,7 +363,7 @@ async function roteiroDoServidor(p, args) {
         estilo: args.estilo || (escolherEstilo({ pedido }) === 'impacto' ? 'impacto' : undefined),
     }, cfg.token);
     if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
-    return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
+    return { ok: true, roteiro: { ...r.roteiro, marca: marcaKit.preencher((args.roteiro && args.roteiro.marca) || p.marca || undefined, { pastas: [p.pasta, process.cwd()] }) } };
 }
 
 async function ferramentaPlano(args) {
@@ -505,6 +507,9 @@ async function ferramentaMidia(args) {
     const p = args.id ? projeto.ler(args.id) : null;
     if (args.id && !p) return semProjeto(args.id);
 
+    if (acao === 'projetos') return require('./projetos.js').procurar({ termo: args.termo, categoria: args.categoria, limite: args.limite });
+    if (acao === 'projeto') return require('./projetos.js').ver(args.nome || args.id_item || args.termo);
+
     if (acao === 'fontes') {
         if (args.conferir) return assets.conferirFonte(args.conferir);
         return { ok: true, fontes: assets.FONTES, biblioteca: biblioteca.cardapio(),
@@ -662,6 +667,86 @@ async function baixarEscolhido(lista, args, p) {
         comoUsar: r.ok ? `no plano: "src": "${r.relativo}"` : undefined };
 }
 
+// ── estudio_ae ───────────────────────────────────────────────────────────
+
+/** O motor After Effects: roda o JSX do agente na pasta do projeto e devolve o mp4 e os quadros. */
+async function ferramentaAE(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    if (!args.script || !args.comp) return { ok: false, error: 'estudio_ae pede script (o JSX) e comp (o nome da composição).' };
+    return require('./cota.js').comCota(() => renderAE(args, p));
+}
+
+async function renderAE(args, p) {
+    const kitM = marcaKit.preencher(null, { pastas: [p.pasta, process.cwd()] });
+    const fontesKit = kitM && kitM.kit ? [kitM.fontes && kitM.fontes.titulo, kitM.fontes && kitM.fontes.texto].filter(Boolean) : [];
+    const r = await require('./effectcraft.js').renderizar({
+        pasta: p.pasta, script: String(args.script), comp: String(args.comp),
+        fontes: [...new Set([...(Array.isArray(args.fontes) ? args.fontes : []), ...fontesKit])], audio: args.audio || undefined,
+        conferir: Array.isArray(args.conferir) ? args.conferir : [],
+    });
+    if (!r.ok) return r;
+    const daMarca = kitM && kitM.kit ? { marca: { nome: kitM.nome, cores: kitM.cores, fontes: kitM.fontes, logo: kitM.logo } } : {};
+    return { ...r, ...daMarca, nota: 'Olhe os quadros (arquivos em ae/) antes de dar por pronto; ajuste o JSX e rode de novo se algo estiver torto.' };
+}
+
+// ── estudio_motion ───────────────────────────────────────────────────────
+
+/** O pacote pra postar (exportar.js) + a galeria; nunca derruba o vídeo. `entrega:false` desliga. */
+function entregar(args, p, r) {
+    const x = r._exportar || {}; delete r._exportar;
+    if (args.entrega === false) return;
+    try {
+        const E = require('./exportar.js');
+        const e = E.exportar({ video: r.video, pasta: p.pasta, assunto: args.assunto, formatos: args.formatos, cenas: x.cenas, palavras: x.palavras, trilha: r.trilha && { ...r.trilha, arquivo: x.trilhaArquivo }, sfx: x.sfx });
+        if (e.ok) {
+            r.entrega = { pasta: e.dir, arquivos: e.arquivos.map((f) => path.basename(f)), creditos: e.creditos, ...(e.avisos ? { avisos: e.avisos } : {}) };
+            E.registrar({ id: p.id, assunto: args.assunto, caminho: r.video, formato: r.formato, duracao: r.duracao, assinatura: r.assinatura, entrega: e.dir });
+        } else r.entrega = { erro: e.error };
+    } catch (err) { r.entrega = { erro: err.message }; }
+}
+
+/** A máquina de motion: assunto + cenas em JSON viram o mp4 (maquina.js), com sons, trilha e voz opcionais. */
+async function ferramentaMotion(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    let receita = null;
+    if (args.receita) {
+        const r = require('./projetos.js').ver(args.receita);
+        if (!r.ok) return r;
+        receita = r.projeto;
+    }
+    return require('./cota.js').comCota(() => renderMotion(args, p, receita));
+}
+
+async function renderMotion(args, p, receita) {
+    const narrar = async (texto, mp3, voz) => rodarPython('narrar.py', ['falar', '--texto', texto, '--saida', mp3, '--voz', String(voz || 'francisca')], { timeout: 5 * 60000 });
+    // Kit de marca ativo: cores, fontes e logo entram onde o JSON não disse; o logo vai no CTA (última cena).
+    const kitM = marcaKit.preencher(args.marca, { pastas: [p.pasta, process.cwd()] });
+    if (kitM && kitM.kit) {
+        args = { ...args, marca: kitM };
+        if (kitM.logo && Array.isArray(args.cenas) && args.cenas.length) {
+            args.cenas = args.cenas.map((c, i) => (i === args.cenas.length - 1 && c && !c.logo ? { ...c, logo: kitM.logo } : c));
+        }
+    }
+    const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
+    if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
+    if (r.ok) entregar(args, p, r);
+    return r.ok ? { ...r, nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' } : r;
+}
+
+// ── estudio_editar ───────────────────────────────────────────────────────
+
+/** O editor por comando: reabre o plano da máquina de motion, aplica as mudanças e guarda a versão (editor.js). */
+async function ferramentaEditar(args) {
+    const id = args.id_video || args.id;
+    const p = id ? projeto.ler(id) : null;
+    if (!p) return semProjeto(id);
+    const r = await require('./editor.js').editar(args, { pasta: p.pasta });
+    if (r.ok && r.versao && !args.listar) projeto.anotar(p.id, 'editar', `v${r.versao}: ${(r.feitas || [r.nota || '']).join('; ').slice(0, 120)}`);
+    return r.ok && r.video ? { ...r, nota: r.nota || 'Mostre o vídeo. Se não era isso, mude de novo ou use voltar_para.' } : r;
+}
+
 // ── estudio_narrar ───────────────────────────────────────────────────────
 
 async function ferramentaNarrar(args) {
@@ -887,7 +972,7 @@ async function ferramentaVideo(args, ctx = {}) {
                 ok: true, proposta: camadas.propor(palavras, m.segundos), duracao: m.segundos,
                 comoUsar: 'é uma SUGESTÃO pela transcrição. Decida você: mude as formas, junte ou separe batidas, '
                     + 'escreva a cena de motion de cada ideia (componentes/x.jsx, recebe {el, t, fps}; el.dados traz largura/altura do espaço livre, '
-                    + 'palavras com t, destaque, cores e fontes) ou use um efeito de fábrica pelo nome (estudio_midia acao:"efeitos"), '
+                    + 'palavras com t, destaque, cores e fontes; a LEGENDA da fala já está no quadro, então a cena NÃO escreve a fala: desenha a ideia) ou use um efeito de fábrica pelo nome (estudio_midia acao:"efeitos"), '
                     + 'e chame de novo com batidas:[{de, ate, rosto, cena?, destaque?, canto?, dados?}].',
             };
         }
@@ -1177,6 +1262,35 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     }
 }
 
+/* A VOZ DO VOICESTUDIO (15/10): o app local fala o roteiro inteiro, e o resto
+   é o caminho do Gemini — volume de Reels, a transcrição para achar as partes.
+   Fechado ou falhando, devolve ok:false e a cadeia segue para o Gemini. */
+async function narrarComVoiceStudio(lista, mp3, { voz } = {}) {
+    if (process.env.PRIMOCODE_SEM_VOICESTUDIO) return { ok: false, indisponivel: true, error: 'voicestudio desligado' };
+    try {
+        const texto = lista.map((x) => x.texto).join('\n\n');
+        // A voz do Gemini ("Kore", "Charon") não existe lá: só um perfil do próprio app.
+        const perfil = /^vs:/i.test(String(voz || '')) ? String(voz).slice(3) : undefined;
+        const r = await voicestudio.falar(texto, { voz: perfil });
+        if (!r.ok) return r;
+        const bruto = mp3.replace(/\.mp3$/, '-vs.mp3');
+        fs.writeFileSync(bruto, r.audio);
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-i', bruto, '-af', 'loudnorm=I=-14:TP=-1.5:LRA=9', '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+        try { fs.unlinkSync(bruto); } catch { /* fica */ }
+        if (!c.ok) return { ok: false, error: 'voicestudio: não consegui converter a voz' };
+        const med = await video.medir(mp3);
+        const chars = lista.reduce((n, x) => n + x.texto.length, 0);
+        if (med.segundos < chars / 22) return { ok: false, error: `voicestudio: a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
+        const cfg = require('../config').loadConfig();
+        const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+        const palavras = (tr && tr.palavras) || [];
+        if (!palavras.length) return { ok: false, error: 'voicestudio: sem a transcrição da voz para achar as partes' };
+        return { ok: true, voz: `voicestudio ${perfil || 'default'}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+    } catch (e) {
+        return { ok: false, error: 'voicestudio: ' + e.message };
+    }
+}
+
 /* Onde estão os rostos em cada foto (studio/rostos.py, pelo uv). Guardado no
    projeto: a mesma foto não é analisada duas vezes. */
 async function acharRostos(p, srcs) {
@@ -1270,7 +1384,9 @@ async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
     if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
     // A voz local pedida (voz: 'kokoro'): direto nela, sem gastar a cota do Gemini.
     if (kokoro.querKokoro(voz)) return kokoro.narrar(lista, mp3, { voz, uv: acharUv() });
-    const v = await narrarComGemini(lista, mp3, { voz, direcao });
+    // O VoiceStudio local primeiro (15/10); fechado ou falhando, o Gemini.
+    let v = await narrarComVoiceStudio(lista, mp3, { voz });
+    if (!v.ok) v = await narrarComGemini(lista, mp3, { voz, direcao });
     if (v.ok) { try { fs.mkdirSync(dir, { recursive: true }); fs.copyFileSync(mp3, cm); fs.writeFileSync(cj, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ } }
     return v;
 }
@@ -1289,6 +1405,7 @@ async function produzirNecessidade(p, roteiro, pedido, provedores) {
    direção dele), o Kokoro local e o Edge. A falha de uma passa para a próxima. */
 function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini, escolha } = {}) {
     const todos = {
+        voicestudio: () => narrarComVoiceStudio(lista, mp3, { voz }),
         gemini: () => gemini(),
         kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
         edge: () => {
@@ -1307,7 +1424,7 @@ function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini
 /* A VOZ DE RESERVA, quando o Gemini falha: o Kokoro (local, sem cota) e
    depois o Edge. A falha de uma passa para a próxima, nunca derruba. */
 function narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge = false, semKokoro = false } = {}) {
-    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && !(semKokoro && n === 'kokoro'));
+    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && n !== 'voicestudio' && !(semKokoro && n === 'kokoro'));
     return kokoro.corrente(passos, {
         kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
         edge: () => rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', kokoro.vozNoEdge(voz, vozEdge)], { timeout: 10 * 60000 }),
@@ -1457,6 +1574,10 @@ async function prepararRoteiro(p, args) {
     const novas = referencias.imagens().filter((f) => !jaTem.has(f));
     for (const f of novas) { try { importarReferencia(p, f); } catch (e) { projeto.anotar(p.id, 'referencia', `não importou ${path.basename(f)}: ${e.message}`); } }
     if (novas.length) p = projeto.ler(p.id) || p;
+    /* O KIT DE MARCA ativo (lib/marca-kit.js) vale mais que a marca lida do
+       site: a pessoa criou uma vez e quer em todo vídeo. O roteiro ainda ganha. */
+    const kitM = marcaKit.preencher({}, { pastas: [p.pasta, process.cwd()] });
+    if (kitM.kit) { p = { ...p, marca: kitM }; }
     if (roteiro.marca) {
         /* A do roteiro por cima da do site, CAMPO A CAMPO: antes o "cores" em
            lista do agente apagava o {fundo, destaque} lido do site (13/10). */
@@ -2567,7 +2688,7 @@ async function ferramentaSite(args) {
 
 module.exports = { proporcaoDoPedido,
     vazamentoNoComeco, variarIcones, objetosDoRoteiro,
-    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
+    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,
 };

package/lib/estudio/kit/gerativo.jsx

@@ -295,6 +295,21 @@ function geometria(a, b, L, P) {
     for (let i = 0; i < N; i++) { const q = -2.3 + (i / (N - 1)) * Math.PI * 2 * 1.1; const e = 1 + (i / N) * 0.07; pts.push([ccx + Math.cos(q) * rx * e, ccy + Math.sin(q) * ry * e]); }
     return { pts, larg: Math.max(4 * base, cx.s * 0.03), alfa: 1, frente: true, cx: ccx, cy: ccy };
   }
+  if (f === 'visto') {
+    /* O ✓ de caneta (15/10, as referências): depois do círculo, ao lado da
+       palavra, em dois traços; se não cabe à direita, encosta na margem. */
+    const pw = alvoPalavra();
+    const s = cx.s, cy0 = cx.y + cx.h * 0.5;
+    const A = [pw.x + pw.w + s * 0.16, cy0], B = [pw.x + pw.w + s * 0.27, cy0 + s * 0.2], C = [pw.x + pw.w + s * 0.52, cy0 - s * 0.3];
+    const dx = Math.min(0, P.largura - 24 * base - C[0]);
+    const q = 0.3;
+    for (let i = 0; i < N; i++) {
+      const k = i / (N - 1);
+      const [p0, p1, u] = k < q ? [A, B, k / q] : [B, C, (k - q) / (1 - q)];
+      pts.push([lerp(p0[0], p1[0], u) + dx, lerp(p0[1], p1[1], u)]);
+    }
+    return { pts, larg: Math.max(5 * base, s * 0.045), alfa: 1, frente: true, tampa: 'round', cx: B[0] + dx, cy: B[1] };
+  }
   if (f === 'barra') {
     // O vão da barra é o respiro do vídeo (margem.js): colada, ela riscava a primeira letra.
     // A deriva da vida abre as letras até 3% da linha para fora: a barra recua junto.