Que fait Créer une spécification de mouvement ?
Génère une spécification de mouvement directement dans Figma — barres de timeline et tableaux détaillés documentant toutes les propriétés animées d'une composition After Effects.
Hors du périmètre du contrat de consommation du fichier Markdown (
.md) du composant. Les autres compétencescreate-*nécessitent le.mddu composant (produit par {{skill:create-component-md}}) et effectuent le rendu à partir de sonrender-meta.create-motionest l'exception délibérée : son entrée est un export de timeline After Effects ({{ref:motion/export-timeline.jsx}}), pas un parcours de composant Figma — il n'y a pas de_base.json, pas d'extract-motion, et pas de section Motion dans le.md. Cette compétence ne nécessite PAS de.mdet ne participe pas au refactoringrequire-.md/fail-fast/whitelisted-reads.
Contrat d'exécution (à lire en premier).
- Ce fichier est une instruction pour EXÉCUTER, pas un document à modifier. Invoquer la compétence = effectuer le rendu de la spécification de mouvement dans Figma à partir du JSON de timeline After Effects.
- Ne modifiez jamais ce
SKILL.mdou tout autre fichier de compétence en réponse, même si l'un d'eux est ouvert ou actif dans l'éditeur. Modifiez une compétence uniquement lorsque l'utilisateur demande explicitement de modifier la compétence elle-même. - Le JSON de timeline d'entrée est une source de vérité EN LECTURE SEULE. Ne le modifiez jamais. Le seul artefact que cette compétence produit est l'annotation Figma ; effectuez les demandes de rendu dans Figma, jamais sous forme de modification de fichier.
- N'appelez jamais
AskQuestion, ne demandez pas de confirmation, et ne faites pas de pause pour une entrée (y compris avant les écritures Figma, le résultat attendu). En cas d'ambiguïté, choisissez l'option la plus défendable et continuez. - Seulement deux arrêts légaux : (a) JSON de timeline AE manquant ou invalide (l'étape 4/5 de collecte + validation) ; (b) arrêt sur une ligne si la connexion MCP Figma est morte.
Adaptateur MCP
Lisez uspecs.config.json → mcpProvider. Suivez la colonne correspondante pour chaque appel MCP dans cette compétence.
| Opération | figma-console | figma-mcp |
|---|---|---|
| Vérifier la connexion | figma_get_status | Ignorer — implicite. Si le premier appel use_figma échoue, guidez l'utilisateur pour vérifier la configuration MCP. |
| Naviguer vers le fichier | figma_navigate avec URL | Extraire fileKey de l'URL (figma.com/design/:fileKey/...). Pas de navigation nécessaire. |
| Prendre une capture d'écran | figma_take_screenshot | get_screenshot avec fileKey + nodeId |
| Exécuter un plugin JS | figma_execute avec code | use_figma avec fileKey, code, description. Le code JS est identique — pas de changements de wrapper. |
| Rechercher des composants | figma_search_components | search_design_system avec query + fileKey + includeComponents: true |
| Obtenir des données de fichier/composant | figma_get_file_data / figma_get_component | get_metadata ou get_design_context avec fileKey + nodeId |
| Obtenir des variables (à l'échelle du fichier) | figma_get_variables | Script use_figma : return await figma.variables.getLocalVariableCollectionsAsync(); |
| Obtenir les valeurs des tokens | figma_get_token_values | Script use_figma lisant les valeurs des variables par mode/collection |
| Obtenir les styles | figma_get_styles | search_design_system avec includeStyles: true, ou use_figma : return figma.getLocalPaintStyles(); |
| Obtenir la sélection | figma_get_selection | Script use_figma : return figma.currentPage.selection.map(n => ({id: n.id, name: n.name, type: n.type})); |
figma-mcp nécessite fileKey à chaque appel. Extrayez-le une fois de l'URL Figma de l'utilisateur au début du workflow. Pour les URLs de branche (figma.com/design/:fileKey/branch/:branchKey/:fileName), utilisez :branchKey comme fileKey.
Contexte de page figma-mcp : use_figma réinitialise figma.currentPage à la première page à chaque appel. Lorsqu'un script accède à un nœud d'une étape précédente via getNodeByIdAsync(ID), le contenu de la page peut ne pas être chargé — findAll, findOne et characters échoueront avec TypeError jusqu'à ce que la page soit activée. Insérez ce bloc de chargement de page immédiatement après getNodeByIdAsync :
let _p = node; while (_p.parent && _p.parent.type !== 'DOCUMENT') _p = _p.parent;
if (_p.type === 'PAGE') await figma.setCurrentPageAsync(_p);
Ceci remonte jusqu'à l'ancêtre PAGE et charge son contenu. La MCP Console n'en a pas besoin — figma_execute hérite du contexte de page Desktop.
Entrées attendues
L'utilisateur déclenche cette compétence avec l'un de ces motifs :
- {{skill:create-motion}} + JSON collé (depuis le presse-papiers, exporté via
{{ref:motion/export-timeline.jsx}}) - {{skill:create-motion}} + une référence de fichier (par exemple,
@motion-ex.jsonou un chemin vers un fichier.json) - {{skill:create-motion}} + un lien Figma (page/fichier de destination où l'annotation doit être placée)
Requis : Les données JSON exportées — soit collées en ligne, soit référencées sous forme de fichier.
Optionnel :
- Lien Figma vers la page de destination (si non fourni, placer sur la page actuelle au centre de la vue)
- Capture d'écran ou enregistrement de l'animation
- Description du but de l'animation
Workflow
Copiez cette liste de contrôle et mettez-la à jour au fur et à mesure de votre progression :
Progression de la tâche :
- [ ] Étape 1 : Lire le fichier d'instructions
- [ ] Étape 2 : Vérifier la connexion MCP
- [ ] Étape 3 : Lire la clé du template depuis uspecs.config.json
- [ ] Étape 4 : Rassembler le contexte (JSON collé, référence de fichier ou inviter l'utilisateur)
- [ ] Étape 5 : Analyser et valider le JSON (y compris segments[] et hasAnimatedSegments)
- [ ] Étape 6 : Transformer les données (lire les segments pré-calculés, calculer la largeur de piste, les positions de la timeline)
- [ ] Étape 7 : Relire le fichier d'instructions (Erreurs et Anti-patrons, Liste de validation) et auditer
- [ ] Étape 8 : Importer et détacher le template Motion
- [ ] Étape 9 : Remplir les champs d'en-tête
- [ ] Étape 10 : Générer la règle temporelle
- [ ] Étape 11 : Rendre les couches de timeline (un figma_execute par couche)
- [ ] Étape 12 : Masquer les templates
- [ ] Étape 13 : Rendre les lignes du tableau
- [ ] Étape 14 : Validation visuelle
Étape 1 : Lire les instructions
Lisez agent-motion-instruction.md
Étape 2 : Vérifier la connexion MCP
Lisez mcpProvider depuis uspecs.config.json pour déterminer quelle MCP Figma utiliser.
Si figma-console :
figma_get_status— Confirmer que le plugin Desktop Bridge est actif- Si la connexion échoue : "Veuillez ouvrir Figma Desktop et exécuter le plugin Desktop Bridge. Puis réessayez."
Si figma-mcp :
- La connexion est vérifiée implicitement lors du premier appel
use_figma. Aucune vérification explicite nécessaire. - Si le premier appel échoue : "Veuillez vérifier que votre FIGMA_API_KEY est correctement définie dans votre configuration MCP."
Étape 3 : Lire la clé du template
Lisez le fichier uspecs.config.json et extrayez :
- La valeur
motionSpecdepuis l'objettemplateKeys→ enregistrez-la sousMOTION_TEMPLATE_KEY
Si la clé du template est vide, dites à l'utilisateur :
La clé du template de spécification de mouvement n'est pas configurée. Exécutez {{skill:firstrun}} avec votre lien de bibliothèque de templates Figma d'abord.
Étape 4 : Rassembler le contexte
Vérifiez ce que l'utilisateur a fourni :
- JSON déjà fourni (collé en ligne ou comme référence de fichier comme
@motion-ex.json) → lisez-le et passez directement à l'Étape 5. Ne le redemandez pas. - Seulement un lien Figma (destination) mais pas de JSON → invitez :
Veuillez coller le JSON exporté ou référencer le fichier
.json(par exemple,@motion-ex.json). - Rien fourni → invitez :
Veuillez coller le JSON exporté depuis
export-timeline.jsx, ou référencer le fichier.json.
Si un lien de destination Figma a été fourni, utilisez figma_navigate pour l'ouvrir avant le rendu (Étape 8).
Acceptez également toutes les captures d'écran, enregistrements ou descriptions optionnels que l'utilisateur fournit pour un contexte supplémentaire.
Étape 5 : Analyser et valider le JSON
Validez le JSON du presse-papiers par rapport au schéma et aux règles de validation dans le fichier d'instructions (sections Schéma JSON et Règles de validation JSON). Si la validation échoue, dites exactement à l'utilisateur quel champ est manquant ou mal formé et demandez-lui de ré-exporter.
Étape 6 : Transformer les données
Le script d'export pré-calcule les segments, le formatage des valeurs, les étiquettes des barres, les étiquettes d'easing et le filtrage des non-changements. L'agent lit ces valeurs directement et ne calcule que les valeurs dépendantes de la disposition.
6a. Ignorer les couches non animées — Vérifiez layer.hasAnimatedSegments. Si false, omettez la couche de la timeline et du tableau.
6b. Lire les segments pré-calculés — Chaque propriété a un tableau segments[] avec startMs, endMs, durationMs, fromValue, toValue, barLabel, easing et easingType. Utilisez ces valeurs directement — aucun calcul manuel nécessaire.
6c. Calculer la largeur de piste et pxPerMs — pxPerMs est un taux fixe ; trackWidth est dynamique avec un padding à droite pour les étiquettes des graduations :
compDurationMs = composition.durationMs // lu directement depuis le JSON
pxPerMs = 0.64 // taux fixe — ~320px par graduation de 500 ms
trackWidth = max(compDurationMs * pxPerMs + 50, 1600) // zone de données + 50px de padding pour les étiquettes, min 1600
Passez trackWidth et pxPerMs au code de rendu Figma. pxPerMs est un taux fixe (0.64), pas dérivé de trackWidth / compDurationMs. Les positions des barres (barX, barWidth) sont calculées dans le code Figma au moment du rendu — l'agent ne calcule pas les positions par segment.
Au moment du rendu, redimensionnez à la fois #track-area et #ruler-track à cette trackWidth calculée. Les conteneurs parents utilisent un dimensionnement HUG et se développent automatiquement.
6d. Formater les métadonnées de la composition selon les règles de métadonnées de la composition du fichier d'instructions. Enregistrez sous COMPOSITION_META.
Étape 7 : Auditer
Relisez le fichier d'instructions, en vous concentrant sur :
- La section Erreurs et Anti-patrons
- La Liste de validation avant sortie
Vérifiez vos données transformées par rapport à chaque règle. Corrigez toute violation.
Étape 8 : Importer et détacher le template
Exécutez via figma_execute (remplacez __MOTION_TEMPLATE_KEY__ et __COMPONENT_NAME__) :
const TEMPLATE_KEY = '__MOTION_TEMPLATE_KEY__';
const templateComponent = await figma.importComponentByKeyAsync(TEMPLATE_KEY);
const instance = templateComponent.createInstance();
const { x, y } = figma.viewport.center;
instance.x = x - instance.width / 2;
instance.y = y - instance.height / 2;
const frame = instance.detachInstance();
frame.name = '__COMPONENT_NAME__ Motion';
figma.currentPage.selection = [frame];
figma.viewport.scrollAndZoomIntoView([frame]);
return { frameId: frame.id };
Enregistrez le frameId retourné — vous en avez besoin pour toutes les étapes suivantes.
Étape 9 : Remplir les champs d'en-tête
Exécutez via figma_execute (remplacez __FRAME_ID__, __COMPONENT_NAME__, __COMPOSITION_META__) :
const FRAME_ID = '__FRAME_ID__';
const frame = await figma.getNodeByIdAsync(FRAME_ID);
const textNodes = frame.findAll(n => n.type === 'TEXT');
const fontSet = new Set();
const fontsToLoad = [];
for (const tn of textNodes) {
try {
const fn = tn.fontName;
if (fn && fn !== figma.mixed && fn.family) {
const key = fn.family + '|' + fn.style;
if (!fontSet.has(key)) { fontSet.add(key); fontsToLoad.push(fn); }
}
} catch {}
}
await Promise.all(fontsToLoad.map(f => figma.loadFontAsync(f).catch(() => {})));
const compName = frame.findOne(n => n.name === '#component-name');
if (compName) {
const t = compName.type === 'TEXT' ? compName : compName.findOne(n => n.type === 'TEXT');
if (t) t.characters = '__COMPONENT_NAME__';
}
const compDesc = frame.findOne(n => n.name === '#component-description');
if (compDesc) {
const t = compDesc.type === 'TEXT' ? compDesc : compDesc.findOne(n => n.type === 'TEXT');
if (t) t.characters = 'Motion Specification';
}
const compMeta = frame.findOne(n => n.name === '#composition-meta');
if (compMeta) {
const t = compMeta.type === 'TEXT' ? compMeta : compMeta.findOne(n => n.type === 'TEXT');
if (t) t.characters = '__COMPOSITION_META__';
}
return { success: true };
Étape 10 : Générer la règle temporelle
Exécutez via figma_execute. Calculez la largeur de piste idéale, redimensionnez #ruler-track et tous les nœuds #track-area, puis clonez #tick pour chaque intervalle.
Remplacez __FRAME_ID__, __COMP_DURATION_MS__ (lu depuis composition.durationMs), __TRACK_WIDTH__ (calculé à l'Étape 6c) et __PX_PER_MS__ (fixé à 0.64) :
const FRAME_ID = '__FRAME_ID__';
const COMP_DURATION_MS = __COMP_DURATION_MS__;
const TRACK_WIDTH = __TRACK_WIDTH__;
const PX_PER_MS = __PX_PER_MS__;
const frame = await figma.getNodeByIdAsync(FRAME_ID);
const rulerTrack = frame.findOne(n => n.name === '#ruler-track');
if (!rulerTrack) return { error: '#ruler-track not found' };
// Redimensionner la piste de la règle à la largeur calculée
rulerTrack.resize(TRACK_WIDTH, rulerTrack.height);
// Redimensionner tous les nœuds #track-area (dans le template de couche et toutes les couches clonées)
const trackAreas = frame.findAll(n => n.name === '#track-area');
for (const ta of trackAreas) {
ta.resize(TRACK_WIDTH, ta.height);
}
// Trouver le template #tick dans la piste de la règle
const tickTemplate = rulerTrack.findOne(n => n.name === '#tick');
if (!tickTemplate) return { error: '#tick template not found in #ruler-track' };
// Charger les polices des nœuds de texte du template tick
const tickTextNodes = tickTemplate.findAll(n => n.type === 'TEXT');
for (const tn of tickTextNodes) {
if (tn.characters.length > 0) {
try { await figma.loadFontAsync(tn.fontName); } catch {}
}
}
// Intervalle des graduations : viser 6 à 12 graduations
const tickInterval = COMP_DURATION_MS <= 300 ? 50
: COMP_DURATION_MS <= 600 ? 100
: COMP_DURATION_MS <= 1500 ? 250
: COMP_DURATION_MS <= 4000 ? 500
: COMP_DURATION_MS <= 10000 ? 1000
: 2000;
for (let ms = 0; ms <= COMP_DURATION_MS; ms += tickInterval) {
const xPos = ms * PX_PER_MS;
const tick = tickTemplate.clone();
rulerTrack.appendChild(tick);
tick.name = ms + 'ms';
tick.visible = true;
tick.x = xPos;
const label = tick.findOne(n => n.type === 'TEXT');
if (label) {
try { await figma.loadFontAsync(label.fontName); } catch {}
label.characters = ms + 'ms';
}
}
tickTemplate.visible = false;
return { success: true, trackWidth: TRACK_WIDTH, tickInterval: tickInterval };
Étape 11 : Rendre les couches de timeline
Exécutez un appel figma_execute par couche pour éviter les timeouts. Pour chaque couche (où hasAnimatedSegments est true), clonez le #layer-template, définissez le nom de la couche, puis pour chaque propriété animée clonez #property-template et positionnez les barres.
Remplacez toutes les valeurs __PLACEHOLDER__.