primocode 11.3.1 → 11.3.2

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v11.3.1
+# PrimoCode v11.3.2
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v11.3.1
+ ▐▛███▜▌   Primo Code v11.3.2
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/plugin/estudio/criar.js

@@ -7,13 +7,13 @@
 
 const path = require('path');
 
-/* tipo → receita. `via`: 'roteiro' (plano pelo roteirista + render) ou 'motion' (a máquina de motion). */
+/* tipo → receita. `via`: 'roteiro' (plano pelo roteirista + render) ou 'kit' (motion pelos estilos: os 50 kits ou um estilo próprio, lib/plugin/kits.js). */
 const TIPOS = Object.freeze({
     slides:   { rotulo: 'Slides', via: 'roteiro', formato: '16:9', projeto: 'slides' },
     video:    { rotulo: 'Vídeo curto', via: 'roteiro', formato: '9:16', projeto: 'video', duracao: [15, 60, 30] },
-    motion:   { rotulo: 'Motion', via: 'motion', formato: '9:16', duracao: [6, 60, 15] },
-    anuncio:  { rotulo: 'Anúncio', via: 'motion', formato: '9:16', duracao: [10, 30, 15], prefixo: 'Anúncio para chamar pra comprar: ' },
-    abertura: { rotulo: 'Abertura de canal', via: 'motion', formato: '16:9', duracao: [5, 5, 5], prefixo: 'Abertura de canal com a marca: ' },
+    motion:   { rotulo: 'Motion', via: 'kit', formato: '9:16', duracao: [6, 60, 15] },
+    anuncio:  { rotulo: 'Anúncio', via: 'kit', formato: '9:16', duracao: [10, 30, 15], prefixo: 'Anúncio para chamar pra comprar: ' },
+    abertura: { rotulo: 'Abertura de canal', via: 'kit', formato: '16:9', duracao: [5, 5, 5], prefixo: 'Abertura de canal com a marca: ' },
 });
 const FORMATOS = ['9:16', '16:9', '1:1'];
 
@@ -28,7 +28,10 @@ function normalizar(args = {}) {
     if (briefing.length < 3) return { ok: false, error: 'falta o briefing: diga em uma frase o que criar.' };
     const formato = FORMATOS.includes(String(args.formato)) ? String(args.formato) : receita.formato;
     const duracao = receita.duracao ? limitar(args.duracao, receita.duracao) : undefined;
-    return { ok: true, tipo, receita, briefing: briefing.slice(0, 600), formato, duracao };
+    const estilo = String(args.estilo || '').trim().slice(0, 60) || undefined;
+    const en = args.estilo_novo && typeof args.estilo_novo === 'object' ? args.estilo_novo : null;
+    const estiloNovo = en && String(en.nome || '').trim() ? { nome: String(en.nome).trim().slice(0, 40), descricao: String(en.descricao || '').slice(0, 300), base: en.base ? String(en.base).slice(0, 60) : undefined } : undefined;
+    return { ok: true, tipo, receita, briefing: briefing.slice(0, 600), formato, duracao, estilo, estiloNovo };
 }
 
 /** Os arquivos entregues, com o tipo que a tela sabe abrir. */
@@ -52,12 +55,12 @@ function tipoDoArquivo(c) {
 
 /**
  * @param {object} args    { tipo, briefing, duracao?, formato? }
- * @param {object} deps    { projeto, plano(args), motion(args), render(args), progresso(pct, etapa) }
+ * @param {object} deps    { projeto, kit(args), plano(args), render(args), progresso(pct, etapa) }
  */
 async function criar(args, deps) {
     const n = normalizar(args);
     if (!n.ok) return n;
-    const { tipo, receita, briefing, formato, duracao } = n;
+    const { tipo, receita, briefing, formato, duracao, estilo, estiloNovo } = n;
     const progresso = deps.progresso || (() => {});
     const falha = (error, extra) => ({ ok: false, error, ...extra });
 
@@ -69,12 +72,16 @@ async function criar(args, deps) {
     const id = proj.id;
     const base = { tipo, id, pasta: proj.pasta, formato, duracao, titulo };
 
-    if (receita.via === 'motion') {
-        progresso(15, 'Montando as cenas de motion');
-        const m = await deps.motion({ id, assunto: pedido, formato, duracao });
-        if (!m || m.ok === false) return falha((m && m.error) || 'o motion não saiu.', base);
-        progresso(100, 'Pronto');
-        return { ok: true, ...base, duracao: m.duracao || duracao, arquivo: m.video, arquivos: arquivosDe(m), resumo: `${receita.rotulo} de ${m.duracao || duracao} s.` };
+    if (receita.via === 'kit') {
+        /* Motion SEMPRE pelos kits (11.1): escolhe o estilo (um dos 50, um criado, ou o da tela de estilos) e monta a pasta
+           do vídeo com as peças desmontadas dele. A cena a IA compõe com as peças e renderiza com `primocode kit pecas`.
+           Nunca cai no gerador antigo (estudio_motion): quem quiser esse caminho chama a ferramenta dele. */
+        progresso(15, 'Escolhendo o estilo e montando as pastas');
+        const k = await (deps.kit || ((a) => require('./kit-projeto.js').montar(a)))({ pasta: proj.pasta, pedido, formato, duracao, estilo, estiloNovo });
+        if (!k || k.ok === false) return falha((k && k.error) || 'não consegui montar o projeto do estilo.', { ...base, ...(k && k.precisa ? { precisa: k.precisa } : {}), ...(k && k.menu ? { menu: k.menu } : {}) });
+        progresso(40, 'Pastas do estilo prontas');
+        return { ok: true, ...base, kit: k.slug, estilo: k.nome, pastaKit: k.pasta, pecas: k.pecas, categorias: k.categorias, etapa: 'cena', proximo: k.proximo,
+            resumo: `${receita.rotulo} no estilo ${k.nome}: pastas montadas, falta compor a cena e renderizar.` };
     }
 
     progresso(15, 'Escrevendo o roteiro');
@@ -99,9 +106,9 @@ module.exports = { criar, normalizar, TIPOS, FORMATOS, tipoDoArquivo, arquivosDe
 const QUADRADOS = Object.freeze({
     slides:  'Tipo escolhido na tela: Apresentação de slides. Use estudio_criar com tipo "slides" e o briefing do pedido (a skill slides-que-prendem ajuda no conteúdo).',
     video:   'Tipo escolhido na tela: Vídeo curto vertical. Use estudio_criar com tipo "video" e o briefing do pedido.',
-    motion:  'Tipo escolhido na tela: Motion. Use estudio_criar com tipo "motion" e o briefing do pedido.',
-    anuncio: 'Tipo escolhido na tela: Anúncio de 15 s. Use estudio_criar com tipo "anuncio" e o briefing do pedido.',
-    abertura: 'Tipo escolhido na tela: Abertura de canal de 5 s. Use estudio_criar com tipo "abertura" e o briefing do pedido.',
+    motion:  'Tipo escolhido na tela: Motion (pelos estilos/kits). Use estudio_criar com tipo "motion", o briefing e o estilo (um dos kits do menu, ou estilo_novo; sem estilo vale o da tela de estilos). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
+    anuncio: 'Tipo escolhido na tela: Anúncio de 15 s em motion (pelos estilos/kits). Use estudio_criar com tipo "anuncio", o briefing e o estilo (um dos kits do menu, ou estilo_novo). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
+    abertura: 'Tipo escolhido na tela: Abertura de canal de 5 s em motion (pelos estilos/kits). Use estudio_criar com tipo "abertura", o briefing e o estilo (um dos kits do menu, ou estilo_novo). Depois siga o caminho "primocode kit pecas <estilo>" que a ferramenta devolve.',
     pagina:  'Tipo escolhido na tela: Página ou app. Construa com write_file na pasta do projeto, confira abrindo no navegador e entregue o arquivo principal. Não use o Estúdio.',
     bug:     'Tipo escolhido na tela: Corrigir um bug. Ache a causa lendo o código do projeto (read_file, grep), corrija com edit_file e crie um teste que pegue o caso; rode os testes e conte o que mudou. Não use o Estúdio.',
     pr:      'Tipo escolhido na tela: Revisar um PR. Leia o diff do PR (o número ou o link que a pessoa der; gh ou git diff), aponte os riscos do mais grave ao menos grave e sugira a correção. Não use o Estúdio.',

package/lib/plugin/estudio/historico.js

@@ -7,7 +7,7 @@ const path = require('path');
 const { tipoDoArquivo } = require('./criar');
 const Miniatura = require('./miniatura');
 
-const PULAR = new Set(['node_modules', 'remotion', 'midia', 'entrada', 'versoes', '.git']);
+const PULAR = new Set(['node_modules', 'remotion', 'midia', 'entrada', 'versoes', '.git', 'pecas']);
 const SAIDAS = new Set(['video', 'pdf', 'imagem']);
 
 /* Procura as saídas em até 2 níveis; imagem solta (quadro de conferência) serve de miniatura, não de entrega. */

package/lib/plugin/estudio/index.js

@@ -750,12 +750,12 @@ async function renderMotion(args, p, receita) {
 
 // ── estudio_criar ────────────────────────────────────────────────────────
 
-/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima. `ctx.progresso(pct, etapa)` alimenta o item da tela. */
+/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima (motion vai pelos kits: kit-projeto.js). `ctx.progresso(pct, etapa)` alimenta o item da tela. */
 async function ferramentaCriar(args, ctx = {}) {
     return require('./criar.js').criar(args, {
         projeto,
         plano: (a) => ferramentaPlano({ ...a, __pasta: ctx.projectDir }),
-        motion: (a) => ferramentaMotion(a),
+        kit: (a) => require('./kit-projeto.js').montar({ ...a, projectDir: ctx.projectDir }, { aoFalar: ctx.aoFalar }),
         render: (a) => ferramentaRender({ ...a, __pasta: ctx.projectDir }, ctx),
         progresso: ctx.progresso,
     });

package/lib/plugin/estudio/kit-projeto.js

@@ -0,0 +1,69 @@
+// O motion pelo sistema de estilos (kits): o `estudio_criar` dos tipos motion, anuncio e abertura passa por aqui.
+// Resolve o estilo (um dos 50, um que a pessoa criou, ou a escolha dela na tela de estilos) e monta a pasta do vídeo
+// com as peças desmontadas do estilo (formas, texturas, transições, tipografia, câmera, sons, trilha, cores, fontes,
+// regras). A cena em si a IA compõe do zero com essas peças e renderiza com `primocode kit pecas` (lib/plugin/kits.js).
+// Nada de gerador antigo aqui: é a 11.1 de kits, só que com a porta simples na frente. Node puro.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const semReferencia = (src) => !/[\\/]referencia([\\/]|$)/.test(src);
+
+/**
+ * @param {object} a   { pasta (do projeto), pedido, formato, duracao, estilo?, estiloNovo?: {nome, descricao, base, ref?}, home?, projectDir? }
+ * @param {object} d   { K (lib/plugin/kits.js), MAT (materiais.js), T (kits-tela.js), aoFalar }
+ */
+async function montar(a, d = {}) {
+    const K = d.K || require('../kits.js');
+    const MAT = d.MAT || require('./materiais.js');
+    const op = { home: a.home, projectDir: a.projectDir || a.pasta, env: d.env, aoFalar: d.aoFalar };
+    let slug = null, nome = null, origem = null;
+
+    // 1) estilo novo, pedido pela IA: copia as peças de um estilo base e devolve o slug
+    if (a.estiloNovo && a.estiloNovo.nome) {
+        const e = a.estiloNovo;
+        const argv = ['criar', '--nome', String(e.nome), '--descricao', String(e.descricao || e.nome)];
+        if (e.base) argv.push('--base', String(e.base));
+        if (e.ref) argv.push('--ref', String(e.ref));
+        const r = await K.main(argv, op);
+        if (!r.ok || !r.slug) return { ok: false, error: r.texto || 'não consegui criar o estilo.' };
+        slug = r.slug; origem = 'criado';
+    }
+    // 2) estilo nomeado (slug ou nome) entre os 50 e os da pessoa
+    if (!slug && a.estilo) {
+        const k = K.achar(a.estilo, op);
+        if (!k) return { ok: false, error: `o estilo "${a.estilo}" não existe. Escolha um do menu ou crie um novo (estilo_novo).`, menu: K.menuParaIA(op) };
+        slug = k.slug; nome = k.nome; origem = 'escolhido';
+    }
+    // 3) a escolha dela na tela de estilos (no primeiro motion a tela abre e a escolha volta)
+    if (!slug) {
+        const m = await K.main(['menu'], op);
+        if (m && m.escolha) { slug = m.escolha; origem = 'tela'; }
+        else return { ok: false, precisa: 'estilo', error: 'falta escolher o estilo: chame de novo com estilo=<slug> (um do menu) ou estilo_novo={nome, descricao, base}.', menu: m && m.texto ? m.texto : K.menuParaIA(op) };
+    }
+    if (!MAT.migrado(slug)) return { ok: false, error: `o estilo ${slug} não tem as peças soltas (materiais/${slug}).` };
+    if (!nome) { const k = K.achar(slug, op); nome = k ? k.nome : slug; }
+
+    // a pasta do vídeo: motion/pecas/<categorias> + kit.json + LEIA.md
+    const raiz = path.join(a.pasta, 'motion');
+    const pecas = path.join(raiz, 'pecas');
+    fs.rmSync(pecas, { recursive: true, force: true });
+    fs.mkdirSync(raiz, { recursive: true });
+    fs.cpSync(MAT.pastaDe(slug), pecas, { recursive: true, filter: semReferencia });
+    const pastas = fs.readdirSync(pecas, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    const arquivos = fs.readdirSync(pecas, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name).sort();
+    const kit = { slug, nome, origem, formato: a.formato, duracao: a.duracao || null, pedido: a.pedido, pecas: path.relative(a.pasta, pecas), criado: new Date().toISOString() };
+    fs.writeFileSync(path.join(raiz, 'kit.json'), JSON.stringify(kit, null, 2) + '\n');
+    const proximo = [
+        `Estilo ${nome} (${slug}): as peças estão em ${pecas} (${pastas.join(', ')}).`,
+        `1) primocode kit pecas ${slug} regras  (identidade e densidade mínima)`,
+        `2) primocode kit pecas ${slug} ver <peça>  (código e params das peças que vai usar)`,
+        `3) escreva a cena nova em TSX com o conteúdo do pedido e grave: primocode kit pecas ${slug} escrever <nome> --arquivo cena.tsx --pasta ${a.pasta}`,
+        `4) renderize: primocode kit pecas ${slug} renderizar <nome> --pasta ${a.pasta}  (o vídeo sai em ${path.join(a.pasta, 'saida')})`,
+    ].join('\n');
+    fs.writeFileSync(path.join(raiz, 'LEIA.md'), `# ${nome}\n\nPedido: ${a.pedido}\n\n${proximo}\n`);
+    return { ok: true, slug, nome, origem, pasta: raiz, pecas, categorias: pastas, arquivos, proximo };
+}
+
+module.exports = { montar };

package/lib/plugin/kits.js

@@ -460,8 +460,9 @@ async function cmdPecas(a, op) {
     const [estilo, sub, alvo] = a._;
     if (!estilo) return { ok: true, texto: `Estilos com peças soltas: ${MATERIAIS.estilos().join(', ') || 'nenhum'}. Uso: primocode kit pecas <estilo> [ver <peça> | regras | escrever <nome> --arquivo <cena.tsx> | conferir <cena.tsx> | renderizar <nome>]` };
     if (!MATERIAIS.migrado(estilo)) return { ok: false, texto: `O estilo "${estilo}" ainda não tem peças soltas (migrados: ${MATERIAIS.estilos().join(', ') || 'nenhum'}).` };
-    const pasta = op.projectDir || process.cwd();
-    const lerArq = (f) => fs.readFileSync(path.resolve(pasta, String(f)), 'utf8');
+    // --pasta <projeto>: a pasta do vídeo que o estudio_criar montou (motion/ e saida/ ficam nela)
+    const pasta = a.pasta ? path.resolve(String(a.pasta)) : (op.projectDir || process.cwd());
+    const lerArq = (f) => { const aqui = path.resolve(op.projectDir || process.cwd(), String(f)); return fs.readFileSync(fs.existsSync(aqui) ? aqui : path.resolve(pasta, String(f)), 'utf8'); };
     try {
         switch (sub) {
             case undefined: case 'listar': return MATERIAIS.listar(estilo);
@@ -477,7 +478,7 @@ async function cmdPecas(a, op) {
                 const dir = path.join(pasta, 'motion', `.render-${alvo}`);
                 MATERIAIS.prepararRender(estilo, dir, arq, { duracao: a.quadros ? Number(a.quadros) : undefined });
                 ligarModulos(dir, est.modulos);
-                const saida = path.resolve(pasta, String(a.saida || path.join('motion', `${alvo}.mp4`)));
+                const saida = path.resolve(pasta, String(a.saida || (a.pasta ? path.join('saida', `${alvo}.mp4`) : path.join('motion', `${alvo}.mp4`))));
                 const CQ = require('./estudio/conferir-quadros.js');
                 const cenas = CQ.cenasDe(fs.readFileSync(arq, 'utf8'));
                 const r = await rodarRender(dir, saida, { escala: Number(a.escala) || 1, quadros: cenas.map((c) => c.meio), aoFalar: op.aoFalar || (() => {}) });
@@ -506,7 +507,7 @@ function opcoes(args) {
 const AJUDA = `primocode kit — os estilos de motion (peças soltas)
   menu                      o menu dos estilos (no primeiro motion abre a tela de estilos)
   ver <slug>                as peças e as regras do estilo (igual a pecas <slug>)
-  pecas <estilo> [ver <peça>|regras|escrever <nome> --arquivo <tsx>|conferir <tsx>|renderizar <nome>]
+  pecas <estilo> [ver <peça>|regras|escrever <nome> --arquivo <tsx>|conferir <tsx>|renderizar <nome>] [--pasta <projeto>]
                             a IA compõe a cena do zero com as peças; o conferir cobra a densidade
   referencia                abre a tela de referências e devolve o que mediu
   criar --nome "<nome>" --descricao "<como é>" [--base <slug>] [--ref <vídeo>] [--quando "a; b; c"] [--familia "<família>"]

package/lib/session/runner/act.js

@@ -1200,7 +1200,8 @@ async function runActInterno(userPrompt, opts) {
         try {
             const kits = require('../../plugin/kits.js');
             kits.novoTurno();
-            const cabeca = kits.cabecaDoPedido(userPrompt, { projectDir });
+            // a instrução do quadrado (Motion, Anúncio, Abertura) também conta: o pedido sozinho ("bolo de pote") não parece motion
+            const cabeca = kits.cabecaDoPedido(instrucao ? `${userPrompt}\n${instrucao}` : userPrompt, { projectDir });
             // o vídeo esperando o sim vai colado na resposta da pessoa (é dela que a IA decide); o menu, na frente
             if (cabeca && /^\[VÍDEO (ESPERANDO|SENDO MONTADO)/.test(cabeca) && pedido.endsWith(userPrompt)) pedido = `${pedido.slice(0, pedido.length - userPrompt.length)}${cabeca}\n\nRESPOSTA DA PESSOA: ${userPrompt}`;
             else if (cabeca) pedido = `${cabeca}\n\n${pedido}`;

package/lib/skill/catalogo.js

@@ -82,8 +82,8 @@ const GRUPOS = [
         nome: 'Estúdio',
         resumo: 'vídeo, motion, slides e arte — a IA faz, e no fim abre o resultado pronto',
         itens: [
-            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: cria slides, vídeo, motion, anúncio ou abertura do pedido ao arquivo, e abre o resultado',
-              args: 'tipo (slides|video|motion|anuncio|abertura). briefing (uma frase). duracao (s, opcional). formato (9:16|16:9|1:1, opcional). Para controle fino use as outras estudio_*.' },
+            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: slides e vídeo vão do pedido ao arquivo; motion, anúncio e abertura escolhem um dos 50 estilos (kits) e montam as pastas do vídeo',
+              args: 'tipo (slides|video|motion|anuncio|abertura). briefing. duracao (s). formato (9:16|16:9|1:1). Motion: estilo (slug do kit) ou estilo_novo {nome, descricao, base}; depois, primocode kit pecas.' },
             { tool: 'estudio_projeto', escreve: true, faz: 'abre, acha e lista os projetos do estúdio — cada peça é uma pasta que não some',
               args: 'acao: criar | abrir | procurar | listar | anotar | editar | assinatura. '
                 + 'assinatura: quando o usuário diz o que achou de um vídeo ("adorei a virada", "texto demais"), grave com texto (e o id) — o próximo vídeo parte disso; sem texto, lê as faixas e as notas. '

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "11.3.1",
+  "version": "11.3.2",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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": {