Communitygithub.com

invokard-studio-local

Crie vídeos com código, inteiramente no computador do usuário: reels e shorts (9:16, 16:9, 1:1) a partir de fotos, clipes, gravações de voz e músicas próprias, com legendas palavra por palavra, títulos animados, gráficos, transições antes/depois, cortes no ritmo da batida, cartas finais e trilha sonora mixada; além de animações quadro a quadro desenhadas com React (texto cinético, anúncios animados, gráficos, 3D, física, partículas). Sem contas, sem chaves de API, sem downloads no momento da renderização.

O que é invokard-studio-local?

Invokard Studio Local é uma skill avançada para agentes de IA (como Claude Code) que transforma descrições textuais em vídeos MP4 prontos para redes sociais, executando todo o processamento localmente no computador do usuário. A skill opera através de dois motores principais: um motor de montagem (reelkit.py) que compõe cada quadro usando Pillow e ffmpeg, e um motor de animação (baseado em React/Remotion) que renderiza componentes quadro a quadro em um navegador headless (Chrome/Edge). O fluxo de trabalho é altamente estruturado: o usuário fornece seu próprio material (fotos, clipes, gravações de voz, música), e o agente orquestra a criação de um arquivo Python (reel.py) que descreve todos os elementos da linha do tempo. A skill suporta múltiplas rotas de criação: a partir de clipes/fotos do usuário, a partir de gravação de voz com legendas, animações desenhadas com React, ou apenas texto e música. Funcionalidades incluem cortes no ritmo da batida, legendas palavra por palavra sincronizadas com a voz, transições antes/depois, gráficos animados, elementos 3D e cartas finais com CTAs. Todos os frames são computados a partir de números (sem aleatoriedade), garantindo renderizações reproduzíveis. A skill não gera nenhum conteúdo com IA (imagens, vídeos, vozes ou música) e não faz chamadas a serviços online – tudo é processado localmente.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Octonove/invokard-studio-local/tree/HEAD/skills/invokard-studio-local

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Invokard Studio Local — do material do usuário ao MP4

Você escreve um pequeno arquivo Python (reel.py) que descreve o reel: qual foto ou clipe está na tela em qual momento, quais camadas (título, chips, itens de lista, gráficos, transições, carta final) aparecem sobre ele, qual arquivo de voz começa quando e onde a música e os efeitos vão. O motor (scripts/reelkit.py) compõe cada quadro com Pillow, os envia para o ffmpeg e mixa o áudio. Nada é editado em um editor de vídeo: toda tipografia, caixas e animações vêm do motor, portanto são nítidos, consistentes com a marca e exatamente sincronizados.

Um segundo motor desenha: animation/ renderiza componentes React quadro a quadro no Chrome ou Edge já presente na máquina (sem cabeça) e os codifica com ffmpeg. Use-o para o que é projetado em vez de filmado: texto cinético, anúncios animados, gráficos que crescem, um produto em 3D, física, partículas, uma foto de produto transformada em anúncio. Sua saída é um MP4 (ou quadros transparentes) que a montagem usa como qualquer clipe ou camada, então um reel pode ter ambos (§ 5).

Tudo é executado neste computador. A skill nunca envia, baixa ou chama um serviço enquanto trabalha: as fontes estão incluídas, os efeitos sonoros estão incluídos e as mídias são do usuário. Leia este arquivo por inteiro, depois a referência para a qual o passo atual aponta. examples/first-reel/reel.py e examples/animated-reel/reel.py na pasta do plugin renderizam reels completos sem nenhuma mídia externa: a verificação mais rápida de que uma máquina consegue renderizar.

0. Verificar a máquina (30 segundos)

python <skill>/scripts/media.py doctor                  # python, ffmpeg, pacotes, fontes, formato
ffmpeg -version && ffprobe -version

Falta do ffmpeg é uma parada obrigatória: diga ao usuário como instalá-lo (references/troubleshooting.md). Faltando Pillow ou numpy: python -m pip install Pillow numpy (baixa do PyPI uma vez; avise antes de executar).

1. Escolher a rota

O material é…RotaReferência
Clipes ou fotos do próprio usuárioA · Filmagem: folhas de contato → selecionar segmentos → cortar na batida → antes/depois → carta finalreferences/footage.md
Um roteiro que o usuário pode gravarB · Voz: o usuário grava um arquivo por frase → legendas palavra por palavra → cortes nas palavrasreferences/production.md
Um anúncio, um título, um gráfico, um produto a ser exibido, sem filmagensC · Desenhado: um projeto de animação (React) → quadro-chave estático → quadros → renderizarreferences/animation.md
Apenas texto e músicaD · Texto na tela: o roteiro do cliente como texto animado sobre fundos desenhados ou fotos, cortado na batidareferences/production.md § Legendas

As rotas se misturam: um reel de filmagem pode conter a voz do usuário; qualquer reel pode conter camadas desenhadas, um gráfico desenhado ou uma carta final desenhada (§ 5).

2. Fluxo de trabalho

  1. Pasta de trabalho — python scripts/new_reel.py <pasta> --brand studio|lime|forest|mono --title "…" [--format 16:9|1:1]. Cria img/ vid/ frames/ vo/ music/ sfx/ ref/ out/ review/ e um reel.py a partir do modelo; o formato (9:16 a menos que solicitado) é definido no topo com rk.set_format(). Marca: pieces.Brand.from_logo('ref/logo.png') mede as cores reais; imprima-as e olhe o arquivo do logotipo primeiro (as pastas estão cheias de nomes de arquivo enganosos).
  2. Roteiro — 85-100 palavras para 35-45 s. Gancho na primeira frase, uma ideia por frase, um final que ecoa o gancho. Apenas afirme o que está no material do usuário: sem números novos, sem novas promessas. Se o usuário forneceu o roteiro, use-o textualmente.
  3. Voz — o usuário a grava, um arquivo por frase (vo/v01.m4a, v02…; mp3, wav e m4a funcionam): um memorando de voz do celular é suficiente. Como pedir e o que fazer enquanto não estiver gravado está em references/production.md § Voz. Depois python scripts/media.py voice <pasta>: durações e intervalos falados; toda sincronização e corte derivam deles. Sem voz (roteiro na tela, apenas música)? Pule para 4.
  4. Imagens e clipes — fotos do usuário em img/, clipes em vid/. python scripts/media.py sheet-img <pasta> e sheet-footage mostram tudo em uma folha: OLHE para ela antes de escolher. Fundos, cartas e gráficos desenhados vêm dos componentes ou do motor de animação.
  5. Editar primeiro com imagens estáticas — escreva reel.py usando pieces.source(nome, 'img/x.png') e execute python reel.py --preview. Olhe para review/preview.jpg. Ajuste ritmo, enquadramento e camadas ANTES de renderizar. Esta etapa é onde o reel é feito; não a apresse.
  6. Clipes — media.py extract corta os segmentos da filmagem real que o reel usa em frames/<nome>/; media.py frames converte clipes inteiros. Verifique a folha de movimento (media.py sheet-motion <pasta>).
  7. Música e efeitos — a própria faixa do usuário em music/ (uma para a qual ele tenha os direitos), ou nenhuma. O motor corta a partir do primeiro ataque e a abaixa sob a voz. Efeitos estão incluídos: pieces.sfx('whoosh'|'pop'|'shimmer'|'chime'| 'typing'|'shutter'|'coaster'|'fridge'). Corte na batida quando não houver voz: media.py beats → references/footage.md.
  8. Renderizar e verificar — python reel.py, depois python scripts/media.py verify out/reel.mp4: especificações, loudness (alvo −14 LUFS) e uma folha de contato extraída do MP4 final. Olhe para essa folha. Depois olhe para 2-3 quadros completos (media.py frame out/reel.mp4 <t>) nos momentos importantes: uma mudança de legenda, a transição, a carta final.
  9. Entregar — out/reel.mp4 + out/cover.jpg (reel.cover(t, 'out/cover.jpg')) + texto da legenda e hashtags em um .md + as fontes (reel.py, img/, vo/, music/, ref/; nunca frames/). Não publique nada: o usuário o faz. Relate o que não pôde verificar (você não pode ouvir a mixagem: diga isso e forneça os números de loudness).

3. Regras que vêm de erros reais

  • Olhe para toda folha. imgs.jpg, motion.jpg, preview.jpg, a folha de verify. Uma renderização não observada não é entregue.
  • Logotipos. Nunca confie em um nome de arquivo. Abra-o. Se for pequeno, reconstrua a marca como texto com as cores medidas.
  • Marcas de terceiros. Nunca adicione um logotipo ou identidade que não seja do usuário (por exemplo, o fabricante de um produto que ele vende). Uma marca pode aparecer porque está na própria filmagem do usuário; nunca é adicionada.
  • Cortes vêm da voz, nunca a olho: caps.word_time(chave, i) e os intervalos de media.py voice.
  • Clipes curtos. Nunca diminua a velocidade de um clipe abaixo de speed=0.8 (fontes a 24 fps trepidam); para alongar, coloque um Still de um quadro do mesmo clipe antes dele com o zoom combinado.
  • Zonas seguras. O Instagram cobre ~220 px no topo e ~360 px na parte inferior. Títulos e chips entre y=230 e y=520; legendas em y≈1440; nada importante abaixo de y≈1560. Tipo mínimo 30 px (chips secundários 36-44, títulos 70+). 16:9 e 1:1 (1080 px de altura): títulos a partir de y≈110, legendas em y≈880, nada importante abaixo de y≈1000. Os componentes obtêm esses padrões de rk.LAYOUT; escreva posições como números apenas quando você as intenciona, nunca copiadas de um reel 9:16.
  • Formatos. rk.set_format('16:9') (ou REELKIT_FORMAT=16:9) vai primeiro, antes de from reelkit import W, H e antes de qualquer fonte ou camada. Extraia clipes para o formato: media.py frames <trabalho> --format 16:9.
  • Legendas em fundos claros precisam de pieces.bottom_gradient(marca) como a PRIMEIRA camada.
  • Música nos clipes do usuário não é dele para reutilizar. Sons reais (uma lavadora, um motor) podem ser extraídos da filmagem com media.py sound; uma música tocando no fundo de um clipe não é uma licença para usá-la.

4. O motor em uma tela (referência completa: references/api.md)

import reelkit as rk; rk.set_format('9:16')                    # '16:9' / '1:1': primeiro, W e H são copiados na importação
from reelkit import W, H, Reel, Captions, Still, Clip, Func, blit, text_img, pill, lerp, clamp01, eo, eio, eback
import pieces as pz; from pieces import source, sfx
rk.set_base(pasta); B = pz.BRANDS['lime'].activate()          # ou pz.Brand.from_logo('ref/logo.png').activate()
reel = Reel('nome'); caps = Captions(size=70, y=1440, maxw=920); reel.caps = caps    # 16:9 / 1:1: Captions(size=62)
t_end = reel.vo('vo/v01.m4a', 0.30)                            # retorna onde a frase termina
caps.line('v01', 'Frase com *palavras*-*chave* *destacadas*, / próximo bloco.', 'vo/v01.m4a', 0.30)   # *hl* · / quebra · mostrada|falada
t = caps.word_time('v01', 2)                                    # o segundo em que a 3ª palavra é falada → corte aqui
reel.shot(0.0, t, source('hero', 'img/hero.jpg', z=(1.0, 1.06), c=(.5, .45)))
reel.shot(t, 5.0, Clip('hero', speed=1.0, start=0.25, z=(1.14, 1.24)))  # frames/hero/ de media.py extract
GRAD = pz.bottom_gradient(B); reel.ov(0.0, 5.0, lambda c, tl, dur, T: c.alpha_composite(GRAD))   # camada: (canvas, tl, dur, t)
reel.ov(0.0, t, pz.headline(B, 'KICKER', 'Linha de gancho', 'FRASE-CHAVE'))
reel.ov(t, 5.0, pz.list_item(B, 1, 3, 'ITEM', 'Benefício em uma linha'))
reel.ov(0.0, 4.0, pz.text_layer('Roteiro do cliente *destacado*'))                   # texto na tela sem voz
SITE = pz.browser_frame('img/site.png', 1000, url='site.com')                      # construir imagens uma vez, fora das camadas
reel.ov(t, 5.0, lambda c, tl, dur, T: pz.appear(c, SITE, W / 2, H * .4, tl, 0))      # captura de tela aparece (phone_frame também)
reel.shot(5.0, 8.0, pz.wipe_scene(src_antes, src_depois, B, hold=1.0))             # antes/depois
reel.shot(8.0, 11.0, pz.outro_save(B, 'img/hero.jpg', 'ref/logo.png', cta='Agende uma chamada · site.com'))
reel.sfx(sfx('whoosh'), t - 0.12, 0.32); reel.sfx(sfx('chime'), 8.3, 0.30)
reel.preview([0.5, 2.0, 4.5, 6.0, 9.0], 'review/preview.jpg', cols=5, scale=0.22)
reel.render('out/reel.mp4', 11.0, music='music/base.mp3', music_gain=0.24); reel.cover(1.2, 'out/cover.jpg')

Camadas são funções f(canvas, t_local, duration, t_global) desenhando RGBA no canvas com blit. Fontes são objetos com .frame(t_local, duration) retornando uma imagem RGB do tamanho do canvas (W x H): Still, Clip, Func(f), e as cenas em pieces (wipe_scene, outro_save, outro_fan, blur_in). Easing: eo (out), eio (in-out), eback (pop). Construa imagens (gradientes, cartas, quadros) uma vez fora da função da camada; texto e comprimidos são armazenados em cache.

5. Animação desenhada (referência completa: references/animation.md)

Configure uma vez: Node.js 18+, depois npm install dentro de <skill>/animation (baixa os pacotes do motor do npm uma vez; avise antes de executar) e node <skill>/animation/cli.mjs doctor. Um projeto é uma pasta com package.json, src/index.jsx (registerRoot + um <Composition> por vídeo) e public/ para seus arquivos. Os componentes importam de 'invokard-studio': useCurrentFrame, spring, interpolate, Sequence, Img + staticFile, OffthreadVideo, 3D de 'invokard-studio/three', e fontes de 'invokard-studio/google-fonts/<Família>' — apenas as quinze famílias incluídas: Inter, Outfit, Figtree, Poppins, Montserrat, Space Grotesk, Barlow, Barlow Condensed, Oswald, Anton, Bebas Neue, Playfair Display, Fraunces, Shrikhand, Caveat. Outro tipo de letra: o usuário coloca o arquivo em public/ e você o declara com @font-face.

node <skill>/animation/cli.mjs still  src/index.jsx Ad out/ad.png --frame 120     # 1. projetar o quadro-chave
node <skill>/animation/cli.mjs frames src/index.jsx Ad out/ad --frames 0,34,68,102,136,170,204,239   # 2. o movimento
node <skill>/animation/cli.mjs render src/index.jsx Ad out/ad.mp4 --props data.json # 3. o vídeo (todos os quadros)

Cada quadro é computado a partir de seu número (sem Math.random, sem relógios, sem animações CSS): os quadros são desenhados fora de ordem em várias abas. Olhe para cada quadro estático e folha de quadros que você renderizar, como faz com os reels. Em um reel:

import animation as an                                                          # scripts/animation.py
an.render('anim/src/index.jsx', 'Title', rk.P('anim/title'), transparent=True)  # quadros PNG com alfa
reel.ov(t0, t1, an.layer(rk.P('anim/title')))                                   # desenhado sobre a montagem
reel.shot(t2, t3, an.clip('anim/src/index.jsx', 'EndCard', 'endcard'))           # um plano desenhado, cortado como um clipe

examples/animated-reel/ na pasta do plugin é um reel completo que faz ambos, sem mídia externa.

6. Lista de verificação da entrega

  • out/reel.mp4 é 1080x1920 (ou 1920x1080 / 1080x1080 conforme solicitado), 30 fps, H.264 + AAC, −14 LUFS ± 1, pico ≤ −1 dBFS (media.py verify)
  • A folha de verificação e 2-3 quadros completos foram observados; legendas nunca ficam abaixo de y≈1560 ou sobre um rosto/produto
  • Toda afirmação na tela está no material do usuário; as cores da marca foram medidas, não adivinhadas
  • out/cover.jpg é legível dentro do recorte central 4:5 do feed
  • Fontes entregues sem frames/; nada publicado

7. O que esta compilação não faz

Ela não gera imagens, clipes de vídeo, vozes, música ou modelos 3D com IA, e não chama nenhum serviço online. Quando uma solicitação precisar de um desses, diga isso claramente no plano: o vídeo pode ser feito agora com as próprias fotos, clipes e gravações do usuário, com animação desenhada (títulos, gráficos, produtos em 3D, ilustrações feitas de formas), ou com arquivos que o usuário trouxer de onde preferir. Não recomende um produto ou serviço específico.

Referências

  • references/production.md — a voz do usuário, legendas, zonas seguras, áudio, marcas.
  • references/footage.md — reels a partir dos clipes do usuário: folhas de contato, extração, grade de batidas, emenda de música, transição, carta final.
  • references/animation.md — o motor de animação: projeto, comandos, API, fontes incluídas, montagem + animação, solução de problemas.
  • references/api.md — toda função de reelkit.py, pieces.py e media.py com seus argumentos, e as posições padrão por formato.
  • references/troubleshooting.md — ffmpeg, fontes, console Windows, renderizações longas.

Habilidades Relacionadas