Communitygithub.com

rizadaniel2-cozy-ritual/remotion-dev

La compétence Remotion Claude est un module TypeScript complet permettant la création et le rendu programmatiques de vidéos directement dans Claude AI. Elle offre une API intuitive pour créer, gérer et rendre des compositions vidéo à l'aide de composants React.

Qu'est-ce que remotion-dev ?

La compétence Remotion Claude Skill permet aux développeurs de créer, gérer et rendre des compositions vidéo directement à partir de Claude AI en utilisant TypeScript et des composants React. Elle offre des fonctionnalités avancées comme la gestion d'une file d'attente de rendu, la prise en charge de multiples formats de sortie (h264, h265, VP8, VP9, ProRes, séquences PNG), un système de templates intégré (intro, animation, diaporama) et une bibliothèque de composants prêts à l'emploi comme TextOverlay. La compétence expose une classe principale `RemotionClaudeSkill` avec des méthodes pour créer des compositions, les enregistrer, les interroger et les soumettre au rendu, le tout avec une sécurité de type TypeScript complète. Elle est conçue pour s'intégrer de manière transparente dans les conversations Claude, permettant une création vidéo interactive et itérative. Idéale pour les développeurs souhaitant automatiser la production vidéo, générer des vidéos paramétrées ou intégrer la création vidéo dans des workflows pilotés par IA sans quitter l'environnement Claude.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/rizadaniel2-cozy-ritual/remotion-dev/tree/HEAD

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Documentation de la compétence Remotion Claude

Présentation

La compétence Remotion Claude est un module TypeScript complet qui permet la création et le rendu programmatiques de vidéos directement dans Claude AI. Elle fournit une API intuitive pour créer, gérer et rendre des compositions vidéo à l'aide de composants React.

Fonctionnalités

  • ✅ Créer des compositions vidéo - Définir des projets vidéo avec des composants React
  • ✅ Gérer les compositions - Enregistrer, récupérer et organiser les compositions vidéo
  • ✅ Gestion de la file d'attente de rendu - Mettre en file d'attente les compositions pour un rendu par lots
  • ✅ Formats de sortie multiples - Prise en charge de h264, h265, VP8, VP9, ProRes, séquences PNG
  • ✅ Système de templates - Modèles pré-construits pour les motifs vidéo courants
  • ✅ Bibliothèque de composants - Composants prêts à l'emploi comme TextOverlay et animations
  • ✅ Sécurité de type - Prise en charge complète de TypeScript avec des interfaces exhaustives

Installation

# Cloner le dépôt Remotion
git clone https://github.com/remotion-dev/remotion.git
cd remotion

# Installer les dépendances
bun install

# La compétence est disponible à l'adresse :
packages/skills-evals/remotion-claude-skill.ts

Démarrage rapide

1. Créer une instance de compétence

import { createRemotionSkill } from './remotion-claude-skill';

const skill = createRemotionSkill({
  projectName: 'mon-projet-video',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 150,
});

2. Créer un composant React

import React from 'react';

export const MaVideo: React.FC<{ titre: string }> = ({ titre }) => {
  return (
    <div style={{
      flex: 1,
      backgroundColor: '#000',
      display: 'flex',
      justifyContent: 'center',
      alignItems: 'center',
      fontSize: 100,
      color: '#fff',
      fontWeight: 'bold',
    }}>
      {titre}
    </div>
  );
};

3. Enregistrer une composition

skill.createComposition(
  'ma-video',
  'Titre de ma vidéo',
  MaVideo,
  {
    durationInFrames: 150,
    fps: 30,
    width: 1920,
    height: 1080,
    defaultProps: { titre: 'Bonjour le monde' },
  }
);

4. Mettre en file d'attente pour le rendu

skill.queueForRender('ma-video', {
  codec: 'h264',
  outputLocation: './output/ma-video.mp4',
  overwrite: true,
});

5. Obtenir les métadonnées

const metadata = skill.getMetadata();
console.log(metadata);
// {
//   name: 'Remotion Claude Skill',
//   version: '1.0.0',
//   compositionsCount: 1,
//   queueLength: 1,
//   ...
// }

Référence de l'API

Classe RemotionClaudeSkill

Constructeur

constructor(config: RemotionSkillConfig)

Crée une nouvelle instance de compétence avec la configuration fournie.

Paramètres :

  • config : Objet de configuration avec width, height, fps, durationInFrames, projectName

Méthodes

createComposition(id, name, component, options?) : CompositionDefinition

Crée et enregistre une nouvelle composition.

skill.createComposition(
  'intro',
  'Séquence d\'introduction',
  IntroComponent,
  {
    durationInFrames: 200,
    fps: 60,
    width: 1920,
    height: 1080,
    defaultProps: { sousTitre: 'Mon projet' },
  }
);
registerComposition(definition) : void

Enregistre une composition déjà définie.

const composition: CompositionDefinition = {
  id: 'outro',
  name: 'Séquence de fin',
  component: OutroComponent,
  durationInFrames: 150,
  fps: 30,
  width: 1920,
  height: 1080,
};

skill.registerComposition(composition);
getCompositions() : CompositionDefinition[]

Retourne toutes les compositions enregistrées.

const toutes = skill.getCompositions();
console.log(`Nombre total de compositions : ${toutes.length}`);
getComposition(id) : CompositionDefinition | undefined

Obtient une composition spécifique par son ID.

const intro = skill.getComposition('intro');
if (intro) {
  console.log(`Trouvée : ${intro.name}`);
}
queueForRender(compositionId, options) : void

Met une composition en file d'attente pour le rendu.

skill.queueForRender('intro', {
  codec: 'h264',
  outputLocation: './videos/intro.mp4',
  crf: 18,
  concurrency: 4,
  overwrite: true,
});
getRenderQueue() : RenderOptions[]

Retourne tous les travaux de rendu en file d'attente.

const fileAttente = skill.getRenderQueue();
console.log(`Travaux en attente : ${fileAttente.length}`);
clearRenderQueue() : void

Vide tous les travaux de rendu en file d'attente.

skill.clearRenderQueue();
getMetadata() : object

Retourne les métadonnées et statistiques de la compétence.

const metadata = skill.getMetadata();
console.log(metadata.capabilities);
generateTemplate(type?) : string

Génère un template pour un composant vidéo.

// Options : 'intro' | 'animation' | 'slideshow'
const template = skill.generateTemplate('animation');
console.log(template);

Interfaces

RemotionSkillConfig

interface RemotionSkillConfig {
  projectName: string;
  width: number;
  height: number;
  fps: number;
  durationInFrames: number;
}

CompositionDefinition

interface CompositionDefinition {
  id: string;
  name: string;
  component: React.ComponentType;
  durationInFrames: number;
  fps: number;
  width: number;
  height: number;
  defaultProps?: Record<string, unknown>;
}

RenderOptions

interface RenderOptions {
  codec: 'h264' | 'h265' | 'vp8' | 'vp9' | 'prores' | 'png';
  pixelFormat?: 'yuv420p' | 'yuv422p' | 'yuv444p';
  crf?: number;
  audioBitrate?: string;
  videoBitrate?: string;
  outputLocation: string;
  concurrency?: number;
  overwrite?: boolean;
  logFn?: (message: string) => void;
  errorFn?: (error: Error) => void;
}

Composants intégrés

TextOverlay

Un composant simple de superposition de texte.

import { TextOverlay } from './remotion-claude-skill';

export const MaVideo = () => (
  <TextOverlay
    text="Bonjour Claude !"
    fontSize={80}
    color="#fff"
    backgroundColor="rgba(0,0,0,0.7)"
  />
);

Utilitaires d'animation

createFadeInAnimation

Génère le CSS pour une animation d'apparition progressive.

import { createFadeInAnimation } from './remotion-claude-skill';

const animation = createFadeInAnimation(150, 30);
// Retourne : "@keyframes fadeIn { ... }"

Templates

Template d'introduction

const template = skill.generateTemplate('intro');

Crée un simple titre textuel affiché sur un fond noir.

Template d'animation

const template = skill.generateTemplate('animation');

Démontre les animations spring et les effets de mise à l'échelle.

Template de diaporama

const template = skill.generateTemplate('slideshow');

Montre comment créer plusieurs séquences pour un effet de diaporama.

Exemple complet

import React from 'react';
import { createRemotionSkill, TextOverlay } from './remotion-claude-skill';
import { useCurrentFrame, useVideoConfig } from 'remotion';

// Créer une instance de compétence
const skill = createRemotionSkill({
  projectName: 'demo',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 300,
});

// Définir le composant
const DemoVideo: React.FC<{ message: string }> = ({ message }) => {
  const frame = useCurrentFrame();
  const { durationInFrames, fps } = useVideoConfig();
  
  const progression = frame / durationInFrames;
  const opacite = Math.min(progression * 2, 1);
  
  return (
    <div style={{
      flex: 1,
      backgroundColor: '#1a1a2e',
      display: 'flex',
      justifyContent: 'center',
      alignItems: 'center',
      opacite,
    }}>
      <TextOverlay
        text={message}
        fontSize={100}
        color="#00d4ff"
        backgroundColor="rgba(0,0,0,0.8)"
      />
    </div>
  );
};

// Enregistrer la composition
skill.createComposition('demo', 'Vidéo de démo', DemoVideo, {
  durationInFrames: 300,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: { message: 'Bienvenue sur Remotion + Claude' },
});

// Mettre en file d'attente pour le rendu
skill.queueForRender('demo', {
  codec: 'h264',
  outputLocation: './output/demo.mp4',
  crf: 18,
  overwrite: true,
});

// Vérifier les métadonnées
console.log(skill.getMetadata());

Fonctionnalités avancées

Compositions multiples

skill.createComposition('intro', 'Intro', IntroComponent, {...});
skill.createComposition('principal', 'Contenu principal', ComposantPrincipal, {...});
skill.createComposition('outro', 'Outro', OutroComponent, {...});

// Mettre toutes en file d'attente pour le rendu
for (const comp of skill.getCompositions()) {
  skill.queueForRender(comp.id, {
    codec: 'h264',
    outputLocation: `./videos/${comp.id}.mp4`,
    overwrite: true,
  });
}

Props personnalisées

interface VideoProps {
  titre: string;
  sousTitre: string;
  duree: number;
}

const MaVideo: React.FC<VideoProps> = ({ titre, sousTitre, duree }) => {
  // Code du composant
};

skill.createComposition('personnalise', 'Vidéo personnalisée', MaVideo, {
  defaultProps: {
    titre: 'Mon titre',
    sousTitre: 'Mon sous-titre',
    duree: 5,
  },
});

Rendu conditionnel

const VideoConditionnelle: React.FC<{ afficherSousTitre?: boolean }> = ({ afficherSousTitre }) => {
  return (
    <div>
      <h1>Contenu principal</h1>
      {afficherSousTitre && <h2>Sous-titre</h2>}
    </div>
  );
};

Bonnes pratiques

  1. Utiliser TypeScript - Tirer parti de la sécurité de type complète pour les composants et les props
  2. Créer des composants réutilisables - Construire une bibliothèque de composants pour les motifs courants
  3. Optimiser les performances - Utiliser la mémoïsation pour les calculs lourds
  4. Rendu par lots - Mettre plusieurs compositions en file d'attente pour réduire la surcharge de démarrage
  5. Gérer les erreurs - Utiliser errorFn dans RenderOptions pour la gestion des erreurs
  6. Valider les props - Toujours valider les props par défaut et les entrées utilisateur

Dépannage

Composition introuvable

try {
  skill.queueForRender('inexistante', {...});
} catch (error) {
  console.error('Composition introuvable :', error.message);
}

Gestion de la file d'attente de rendu

// Vider la file d'attente avant d'ajouter de nouveaux travaux
skill.clearRenderQueue();

// Vérifier la longueur de la file d'attente
console.log(`Rendus en attente : ${skill.getRenderQueue().length}`);

Validation de la configuration

const config = skill.getMetadata();
console.log('Configuration actuelle :');
console.log(`- Résolution : ${config.config.width}x${config.config.height}`);
console.log(`- FPS : ${config.config.fps}`);
console.log(`- Durée : ${config.config.durationInFrames} images`);

Intégration avec Claude

Dans les conversations Claude

  1. Faire référence à la compétence pour créer des vidéos de manière interactive
  2. Modifier les composants en temps réel
  3. Mettre plusieurs versions en file d'attente pour comparaison
  4. Exporter la configuration au format JSON

Exemple d'interaction Claude

Utilisateur : "Crée une vidéo d'introduction pour mon podcast"

Claude : Je vais créer une vidéo d'introduction en utilisant la compétence Remotion Claude.

skill.createComposition('intro-podcast', 'Introduction du podcast', IntroPodcast, {
  durationInFrames: 180,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: {
    nomPodcast: 'Nom de votre podcast',
    slogan: 'Des conversations qui comptent',
  },
});

Liens utiles

Licence

Cette compétence suit la même licence que Remotion. Voir LICENSE.md pour plus de détails.

Contribution

Pour contribuer des améliorations à cette compétence :

  1. Forker le dépôt
  2. Créer une branche de fonctionnalité
  3. Apporter vos modifications
  4. Soumettre une demande d'extraction

Voir CONTRIBUTING.md pour plus d'informations.

Support

Skills associés