spine-mcp

Adds one Spine 4.3 JSON animation to a .spine project. Dry-run validates against the skeleton; apply backs up, imports only this animation through the CLI, re-exports, verifies and rolls back on any mismatch. Existing names need replace; prefer a new name. Times in seconds; rotate uses value; bezier curve is absolute [cx1,cy1,cx2,cy2] per channel.

Validate, rig QA and budget on every .spine and skeleton .json under a folder: one ok/fail row per skeleton (strict: validation warnings fail too). For release checks and CI.

Starting rig in a new project from a layered PSD or parts + layout: bones at joints, traced meshes, weights, optional two-bone IK; hidden lids rigged shut-collapsed. Without bones: suggests a skeleton over the art (nothing written; riders: one character sits on another; rigFrom: an approved rig's joints); pass back as bones. With bones: dry-run with checks; apply writes, validates, runs rig QA, renders test poses. Never overwrites.

Spine Metrics over the setup pose and every frame: attachments, vertices, vertex transforms, triangles, area, clipping, draw call estimate, timelines, constraint costs; worst values with animation@time. limits for pass/fail; draw calls need atlas or pack (~4 s).

A/B of two animations of one skeleton: duration, motion ratio, per-bone changes (biggest first), timing structure; optional contact sheets.

Builds a new animation from an existing one with ops applied in order on the server, then adds it like spine_add_animation (validated, backed up, verified; dry-run unless apply). Ops: docs/USAGE.md#derive-operations.

Checks the Spine CLI, editor version and license, spine-core version and work folder. Run first when something fails.

Is a Spine editor window open (and likely on this project)? While it is, writes go to a verified staging copy. With project: what still waits in the staging copy; animations confirms each one after Import Project and a save.

Exports runtime files (JSON and/or .skel plus a packed atlas, optional scales), verified with spine-core in a temp folder before copying to outputDir (no overwrite unless set; project untouched, ~3-5 s). Reports page fill and texture memory. sweep: ranks atlas settings by texture memory and pages, writing nothing.

Exports a .spine project's skeletons to JSON in the cache folder (never next to the project); re-exports only when the project changed.

A new animation of one type (fill only that type's object), added like spine_add_animation (validated, backed up, verified; dry-run unless apply). Missing bones/slots: suggestions by name, nothing written. breathe: torso scale or figure8, followers later; restStart. sway: chain swing. settle: decay after a gesture. blink: eye swaps and/or lid bones; onPoses hides head moves. gaze: eye darts between fixations; brows lift, arch, dip. lookAt: eyes lead, neck-to-head follows. followThrough: secondary motion baked over a source. turn: 2.5D head turn; squash: squash/stretch (mesh deform). walk: in-place cycle. blocking: pose-to-pose. lipSync: mouth/jaw from audio. Seconds, degrees, skeleton units; docs/USAGE.md#generate-options.

New Spine project from a layered PSD: a region per layer at its canvas position, draw order from layer order, bones from groups (or PhotoshopToSpine tags), images next to it; masks baked, unsupported effects reported. Or json: PhotoshopToSpine's output (checked). Or parts: PNGs placed by a layout JSON (See-through, cut-boxes or {parts:[{file,x,y|bbox|center,order,bone,pivot,slot}]}). Dry-run by default, never overwrites; verified by re-export and a render against the PSD or the placed parts. Places art only.

Skeleton structure. view summary (default): counts, bone tree, constraints, per-animation stats; bones|slots|skins|constraints: raw section JSON; animation: every timeline with exact keys.

Backups made before writes (newest first), ids for spine_restore_backup.

Samples an animation in spine-core (constraints, physics warmed up); per bone: rotation range, path, peak speeds, pops, holds, loop seam. rootMotion: what SkeletonRootMotion reads (travel, sliding feet, in-place speed). parts: how far each slot travels.

Plays transitions with spine-core's AnimationState like a game (mixes, optional base track), switching at several points; reports pops with phase and likely cause, timelines first keyed after 0, and events lost inside the mix. runtime mecanim: as spine-unity's SkeletonMecanim, plus the keys each incoming animation needs (setupKeys).

Onion skin, bone arcs (one dot per frame) and value curves of one animation as an image, plus the numbers. Bones default to the 3 that travel furthest.

Fast CLI summary (Spine -i): editor version, FPS, skeletons, bone/slot/constraint/animation lists. Several paths per call (one ~3 s CLI start).

Timing from a reference video (optional crop): motion peaks, holds, cuts and repeat period as a frame table, graph and sheet. compare aligns a Spine animation on the peaks (speed ratio, offset, per-peak frames).

Compares a project with a snapshot (default latest) or another .spine/.json: what broke (lost keys, weights, meshes, removed items) and what changed, then where playback of common animations now differs.

Renders an animation with Spine's renderer (~4 s, cached) and returns a contact sheet. No MSAA or physics warm-up: for checking, not final video.

Puts a backup back. Dry-run by default; apply backs up the current file first, then restores atomically.

Review cut MP4: each animation rendered by Spine at each speed, every frame labelled (animation, speed, frame, time); optional audio under real-time passes and a title card. Writes only output.

Adds bones, IK, physics, events and skins, sets setup poses, removes constraints, traces regions into meshes in place (meshRegion), copies meshes from another rig (copyMesh); written to a NEW .spine via JSON import (original untouched), listing what else the round trip changed. Dry-run by default; one skeleton.

Rig hygiene: names (spaces, clashes, default names, mixed left/right styles), unused bones, attachments, slots and events, bad setup scale, weights not summing to 1, too many influences, weights that fold when a bone turns, joints that open, art a mesh cuts off, missing or unused images. Complements spine_validate.

1-4 animations rendered by Spine side by side, labelled, as an animated .webp (alpha), .gif or .mp4 written only to output. For before/after and reels. Needs ImageMagick plus img2webp or ffmpeg.

Checks each skin, or mix-and-match combinations: attachment counts, slots several skins set (last wins), slots none fills, and each one's budget over every frame. atlas or pack for exact draw calls.

Saves a labelled, verified backup copy before risky editor work (compare later with spine_reimport_diff). Without label: lists snapshots.

Instant, no CLI: file state, editor window, staging copy, backups, spine-mcp's last steps on the project and outside changes since. Call first when resuming work.

Timing structure from the keys: key poses and intervals, segment durations, ease type per segment, holds.

Copies an animation to another skeleton or project, matching names (exact, map, then case/separator-insensitive); reports what matched, renamed or could not move, then adds it like spine_add_animation (dry-run by default). copies: merge mode for animators on copies of one project: what each copy added or changed, conflicts (resolve with prefer), then writes into the base (to).

Fresh export into a throwaway Unity project, every animation vs spine-core bone by bone (~30 s); perf: CPU/GC per skeleton. Options: docs/USAGE.md#into-your-unity-project.

Imports a .spine into a Unity project with spine-unity (data, atlas, materials, mixes, prefab), then compares it bone by bone with spine-core; reports texture settings and render pipeline. Dry-run by default. update: replace in place (backed up, GUIDs kept). With Unity open, only files are copied. audit: read-only scan (version, data files, API changes).

Updates a project's image files from a layered PSD without touching the .spine: layers matched to images and cut to their frames, so meshes and animations stay valid. placement psd takes the PSD's layout; grow enlarges a region image. Dry-run with before/after renders; apply backs up and writes. restore: a backup id.

Finds problems: duplicate names, bone order, missing references (Spine drops them on import), mesh indices, key order, curves, keys on physics bones; samples every animation in spine-core (NaN, loop seams, clamps, invisible keys, mesh folds, joints opening). face: blinks vs pose changes and mouth swaps, lashes while shut, mouth bones, blink timing.

Exact video frames by number (spine_video_inspect's numbering) as a labelled sheet; diff marks changes in red, onion blends them. Up to 48 per call.

Frame-by-frame video check: encoding (VFR, size, pixel format, audio), segments at cuts and transitions with hold pattern (ones/twos), flashes, stutters, dropped frames, motion peaks, audio onsets vs cuts/peaks; an event list, per-frame curves and an overview sheet. verify compares a segment with a Spine animation. Exact frames: spine_video_frames.

Renders a fresh export with spine-webgl in headless Chrome and compares every frame with Spine's render (silhouette IoU, colour difference, worst frame). Needs Chrome or CHROME_BIN.