Communitygithub.com

automatic-storyteller-animate

Montre à un agent comment planifier, construire ou monter un film « automatic storyteller animate » afin que le résultat concret soit un montage vidéo terminé. La procédure parcourt Automatic storyteller animate, Avant de commencer — la vérification des prérequis (automatique), Ce qu'il produit (le rendu). Utilisez-le lorsqu'une nouvelle mission nécessite ce savoir-faire.

Qu'est-ce que automatic-storyteller-animate ?

Ce skill orchestre automatiquement la production d'un film narratif complet à partir d'un fichier vocal et d'un script, sans storyboard manuel ni montage. Il transcrit la voix, synchronise chaque ligne de légende, sélectionne une mise en page par ligne (croquis de tableau blanc à la craie, icônes néon et traits tremblants alternant avec un mur de preuves sombre composé de vraies photos Wikimedia Commons, documents et fiches), rend chaque bloc de style comme son propre clip, les assemble image par image, grave des légendes néon en bas de l'écran, mixe des effets sonores synchronisés avec les mots à -19 dB avec une musique sous licence CC à -18 dB, normalise à -15 LUFS et effectue un contrôle qualité des images, du volume sonore et du placement des légendes. Il est idéal pour les prompts tels que « crée un film à partir de cette voix et de ce script », « automatic storyteller animate », « transforme ma narration en vidéo », « vidéo comme le film de l'agent d'exploitation IA », « court métrage narré et scénarisé à partir d'un fichier audio » ou toute demande où l'entrée est un fichier vocal accompagné d'un script. Le skill prend en charge les pipelines CLI via `run.py`, utilise un cache de production pour éviter de refaire les étapes inchangées, et repose sur deux skills compagnons : `cinematic-film` (rendu, photos, son) et `remotion-studio` pour un aperçu optionnel.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/omnieditxstudio-IT/Automatic-Storytailer-Animate/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

Automatic storyteller animate

Donnez-lui un fichier vocal et un script. Il termine tout le film : timing, mise en page, rendu, coupes, légendes, son, mixage et contrôle qualité. Pas de storyboard manuel, pas de code de scène, pas de timeline de montage.

python scripts/run.py --project mon-film --voice voix.mp3 --script script.md

Cette seule commande exécute le pipeline complet et produit mon-film/out/FILM.mp4, mon-film/out/FILM.srt (à côté de captioned.mp4), credits.md, beats.json, plan.json, beats.md, des images de révision dans out/qa/ et tous les fichiers intermédiaires.

Avant de commencer — la vérification des prérequis (automatique)

Chaque exécution commence par check_requirements.py, avant toute autre chose. Si tous les outils disponibles sont installés, la production continue immédiatement — aucune configuration nécessaire. Si quelque chose manque, il est téléchargé/installé automatiquement, puis la production continue.

Il vérifie, dans l'ordre :

  1. Python 3.8+
  2. Paquets Python — numpy, skia-python, Pillow, faster-whisper — installés automatiquement via pip si manquants
  3. ffmpeg + ffprobe dans le PATH — installés automatiquement via winget (Windows), brew (macOS) ou apt-get (Linux) si manquants
  4. cinematic-film à côté de ce skill (ou CINEMATIC_SCRIPTS=<chemin vers ses scripts>)

Si tout est présent : une ligne — requirements: ok — et la construction commence. Si un paquet Python ne peut pas s'installer, le script affiche la commande exacte pour le corriger et se termine au lieu de lancer une construction vouée à l'échec. Si cinematic-film est introuvable, même chose — vous obtenez exactement ce qui manque et quoi définir.

Ce qu'il produit (le rendu)

Deux langages visuels qui alternent systématiquement toutes les 3 à 10 secondes, décidés par bloc par le réalisateur :

  • Planche - une feuille de plan pleine page. Les mots apparaissent comme une typographie à la craie dessinée à la main sur une grille bleu foncé, avec des boîtes d'appel de croquis, des traits tremblants, des fenêtres de code griffonné, des coches, des séparateurs et des icônes néon (deux passes de lueur + noyau chaud) qui sont dessinées dans le code.
  • Photo - le mur de preuves nocturne de cinematic-film : de vraies photos Wikimedia Commons sous licence épinglées avec une ombre portée et une épingle, des documents papier composés, des règles de surbrillance tremblantes, des icônes néon lumineuses, tous crédités dans credits.md.

Les légendes sont centrées en bas et affleurantes au bord inférieur (6 px en 720p, mise à l'échelle selon la résolution), en majuscules, dans l'une des neuf encres pastel déterminées, avec une entrée adoucie (montée/pop/glissement/inclinaison/fondu/balayage/chevauchée) et une sortie (fondu/chute/montée sortante/rétrécissement), un halo de bloom à trois passes, un dégradé arc-en-ciel sur le mot prononcé (contour blanc tube néon). Un dégradé derrière la bande les maintient lisibles sur tout support. Le texte reflète exactement la voix.

Démarrer un nouveau projet vs. reprendre

  • Nouveau projet : fournissez la voix et le script ; le skill construit tout.
    python scripts/run.py --project mon-film --voice voix.mp3 --script script.md
    
  • Reprendre : relancer sur un projet qui a déjà out/FILM.mp4 (et le plan/les photos) ne revérifie qu'avec le contrôle qualité — rien n'est re-téléchargé ou re-rendu. Ajoutez --force pour reconstruire à partir de zéro.

Entrées

  • --voice : tout fichier audio que ffmpeg lit (mp3/wav/m4a...). Meilleurs résultats avec une narration propre en une seule prise. Il est utilisé tel quel, uniquement converti en AAC stéréo 48 kHz.
  • --script : .md / .txt / .srt / .json. Les titres Markdown deviennent des accroches de section à l'écran ; les lignes vides et les paragraphes sont divisés en phrases, puis en blocs de légende (<= 9 mots / <= 64 caractères). Le texte à l'écran est le texte du fichier, textuellement. script.json avec {"title": ..., "takes": [...]} est respecté lorsqu'il est présent.

Options

OptionEffet
--size 1920x1080taille de rendu (par défaut 1920x1080)
--crf 16qualité (plus bas = meilleur ; 16 film, 26 aperçu)
`--photos autoexisting
`--music autonone
--model tiny.entaille faster-whisper pour l'alignement (base.en/small.en sont plus précis)
--previewne rendre que les blocs 0-1 en 640x360 pour un aperçu rapide
--skip-renderre-planification uniquement (pas de rendu)
--workers WORKERSworkers de rendu + légendes (0 = tous les cœurs moins un)
--forcereconstruire même si un out/FILM.mp4 terminé existe déjà

Performance et sécurité

  • Cache de production à E:\Storyteller catche files (remplacez avec STORYTELLER_CACHE). Chaque artefact lourd est mis en cache sous un hash de contenu, donc relancer ou ajuster des étapes ultérieures ne refait que ce qui a changé :
DossierCe qui est mis en cacheClé
whisper/synchronisation des mots faster-whisperfichier vocal + modèle + périphérique
commons_search/résultats de recherche Commonsrequête + limite
commons_files/originaux Commons téléchargés + fichiers de crédittitre Commons
blocks/blocs de style rendusscène + beats + géométrie du bloc + taille + CRF
silent/film silencieux assembléfichiers de blocs + CRF + fps
captioned/film avec légendes + SRTvidéo + timing + code des légendes + CRF
sfx/bus SFX synthétiséfeuille de repère + build_sfx.py
music/bande sonore en bouclefichier de musique + durée du film
mix/mixage audio finalvoix + repères + musique + niveaux + LUFS

Les fichiers sont nommés <label>-<hash12>.<ext> et triés par type (un listing sort se lit naturellement), avec un manifeste index.jsonl en ajout seul et un README.txt à la racine. Les absences de cache se reconstruisent automatiquement ; supprimer le cache est toujours sûr. Une réexécution complète des étapes inchangées prend quelques secondes (whisper/blocs/assemblage/légendes/sfx/mix atteignent tous le cache).

  • Chaque bloc est rendu séparément, puis les blocs sont assemblés avec un filtre concat image par image. Relancer après une modification du script ne re-rend que les blocs dont le plan a changé (render_blocks.py réutilise les fichiers de blocs frais, plus le cache de production comme deuxième couche).
  • 12 cœurs / beaucoup de RAM : utilisez --workers 6. Un film de 3 minutes en 1080p prend environ 15 à 30 minutes.
  • Ne rendez jamais le film final sans que l'utilisateur le demande : utilisez d'abord --preview ou un petit --size, montrez-le, et ne produisez FILM.mp4 en pleine taille qu'ensuite.
  • Whisper tiny.en est environ 1x le temps réel sur CPU ; utilisez --model base.en si les synchronisations dérivent sur les longues lignes.

Ce que fait le réalisateur

Chaque ligne de légende devient un beat. Un beat reçoit exactement une mise en page choisie parmi ses mots :

Mise en pageDéclencheurDessin
title / end2 premières / 2 dernières lignesicône néon + grand titre à la craie (titre = titre en casse des mots de contenu de la ligne)
chainpremier/second/ensuite/processus/pipeline3 boîtes de croquis avec flèches
splitavant/après/versus/comparé/plutôtdeux cadres étiquetés de chaque côté d'un séparateur déchiré
windowcode/script/terminal/agent/modèle/serveurfenêtre de terminal dessinée à la main avec lignes griffonnées + ligne surlignée
checkprotéger/patcher/sécuriser/empêcher/jamaiscoches à la craie dans une liste
stattout nombreénorme chiffre lumineux
quotetout le reste / questionscitation à la craie
variantes phototous les autres blocsstation (photo + fiche), doc (document papier + tampon), stat

Les lignes consécutives (1-4, max ~9 s, coupées aux fins de phrase) se regroupent en blocs ; les blocs alternent planche/photo sur tout le film. Les premier et dernier blocs sont toujours des planches.

Fichiers écrits

audio/narration.m4a   voix normalisée
audio/timing.json     début/fin par ligne (schéma du moteur)
script.json           prises dans l'ordre de parole, ordre des identifiants conservé
beats.json            par ligne : début/fin/mise en page/accroche/titre/points/numéro/icône/encre/photo/x
plan.json             blocs (style, plage d'images, monde x), fps, durée
beats.md              tableau humain de tout le plan
sfx_cues.json         effets synthétisés pour build_sfx.py
photos.json           sélections Commons avec licence/crédit/source
out/blocks/bNNN.mp4   un clip par bloc de style
out/silent.mp4        image assemblée
out/captioned.mp4     + légendes néon gravées (+ .srt)
out/FILM.mp4          final, avec audio mixé
out/qa/*.png          images de révision
credits.md            crédits des images + de la musique

Passerelles QA (scripts/qa.py, exécutée automatiquement par run.py)

Échoue la construction en cas de : décalage du nombre d'images vs timing.total_duration * fps, flux audio manquant/absent, volume sonore en dehors de -15 +/- 1.5 LUFS, pic vrai > -0.8 dBTP, un bloc de légende non visible, ou une ligne de base de légende à plus de 8,5 % de la hauteur de l'image au-dessus du bord inférieur.

Skills compagnons (comment une production se termine réellement)

Ce skill est l'orchestrateur dédié au flux de travail des films éducatifs/explicatifs ("vidéo comme le film de l'agent d'exploitation IA"). Il pilote deux skills compagnons pour terminer une production, exactement comme les films précédents ont été réalisés — vous ne les appelez jamais directement ; run.py et qa.py le font. La règle est absolue : ne modifiez jamais un skill compagnon — ou tout autre projet (par exemple C:\remotion-build\dark-reality-explainer) — pour faire fonctionner celui-ci ; pilotez-les tels qu'ils sont livrés. Toute la logique d'orchestration, le cache, la QA et les décisions de style résident ici dans ce skill.

1. cinematic-film — le monde, les photos, le son (obligatoire, dépendance stricte)

Situé à côté de ce skill (remplacez avec CINEMATIC_SCRIPTS=<chemin vers son répertoire de scripts>). Appelé par :

ScriptUtilisé parCe qu'il fait pour ce film
prep_assets.pyétape prepgradue les photos Commons dans le style noir et blanc (`--grade bw
fetch_commons.pyfetch_photos.pytélécharge les originaux sous licence (get), remplit le fichier/le crédit/la licence, et écrit credits.md (credits)
render.pyrender_blocks.pyrend chaque bloc de style avec --t0/--t1 ; dessine le monde planche/photo, la caméra et chaque élément par image
engine.pystoryboard.py, chaque rendule modèle du monde : Film, touches de caméra, Board, PaperDoc, StylePanel, la caméra spline
captions.pycaptions_burn.pyl'horloge des mots (words_with_times) utilisée pour chronométrer le mot chaud
build_sfx.pyaudio_finish.pysynthétise le bus d'effets à partir de sfx_cues.json (aucune bibliothèque d'échantillons à licencier)
mix_soundtrack.pyaudio_finish.pyvoix + SFX + musique : SFX à -19 dB, musique à -18 dB, ducking 4:1, master -15 LUFS / -1.5 dBTP

Règles d'engagement : ne modifiez pas ses scripts pour ce skill — les changements de comportement appartiennent à storyboard.py / render_blocks.py / ici. Ses contrats CLI (--t0/--t1, fetch_commons get|credits, mix_soundtrack --lufs) sont ce que le cache de production hache ; si cinematic-film en change un, mettez à jour l'étape ici et supprimez E:\Storyteller catche files pour qu'aucun hit obsolète ne survive.

2. remotion-studio — aperçu navigateur / pilotage (optionnel, révision uniquement)

npx remotion studio (ouvrez l'URL imprimée ; ou --no-open et ouvrez l'URL vous-même).

Périmètre honnête, pour que personne ne perde de temps : Studio ne prévisualise que les compositions Remotion — des composants React enregistrés dans un projet Remotion. Il ne peut pas lire le master terminé de ce skill (out/FILM.mp4 est un rendu skia/ffmpeg, pas un projet Remotion ; le film AI-attack non plus). Utilisez-le lorsque le livrable existe aussi en tant que projet Remotion et que vous souhaitez l'expérience de prévisualisation pendant l'édition (ou pour piloter une variante basée sur Remotion). Pour réviser la sortie de ce skill lui-même, utilisez out/FILM.mp4 / out/preview_captioned.mp4 plus les images out/qa/ — Studio n'a rien à quoi se connecter.

La recette de production (comment les trois skills terminent un film, comme la dernière fois)

  1. Voix + script -> run.py --preview (2 blocs, 640x360, ~2 min). Vérifiez le rendu, le rythme planche/photo, la taille des légendes et l'affleurement en bas, et que qa.py indique SUCCÈS.
  2. Plan complet — ingestion (alignement whisper) -> réalisateur (beats, mises en page, alternance de style) -> photos Commons (licence libre, crédits dans credits.md) -> préparation (gradation nb) -> scène -> repères.
  3. Rendu — chaque bloc séparément en 1080p ; réutilisez via le cache de production sur E:\Storyteller catche files.
  4. Finalisation — assemblage (filtre concat) -> légendes néon affleurantes en bas -> SFX -19 dB / musique -18 dB, ducking, master -15 LUFS.
  5. Révision — out/FILM.mp4 se lit ; out/qa/ contient les images. Si une étape d'empaquetage/révision Remotion est souhaitée, ouvrez ce projet Remotion avec remotion studio et vérifiez qu'il se charge là.
  6. Livraison — FILM.mp4 + FILM.srt + credits.md. Le téléchargement/l'exportation se fait en dehors de ce skill.

SRT / côté distribution de la production

Après qa SUCCÈS : out/captioned.srt se trouve à côté de out/captioned.mp4 (l'étape de finalisation peut le copier à côté de FILM.mp4). Pour les variantes sociales (re-coupes 9:16, exportations plateforme, mise en scène de vignettes), utilisez un skill de distribution plutôt que de re-rendre dans celui-ci — ce skill produit uniquement le master 16:9.

Prérequis

Voir Avant de commencer — la vérification des prérequis ci-dessus : Python 3.8+, numpy, skia-python, Pillow, faster-whisper, ffmpeg/ffprobe dans le PATH, et le skill cinematic-film à côté de celui-ci (remplacez avec CINEMATIC_SCRIPTS). La vérification s'exécute automatiquement au début de chaque exécution.

Limites connues

  • L'alignement utilise whisper tiny.en par défaut ; une parole marmonnée peut dériver pendant …

[suite tronquée pour la traduction]

Skills associés