Skip to content

notque/vexjoy-agent / skills/game/game-dev

game-dev

Flagged

Game development: design, asset pipelines, Phaser, Unity CLI and builds, vanilla JS frontend, GM mode, match booking.

FileKindSize
SKILL.mdskill md13.2 KB
references/anchor-alignment.mdmarkdown16.0 KB
references/animate-scaffolds.mdmarkdown2.0 KB
references/arcade-physics.mdmarkdown7.4 KB
references/artifacts-and-prototyping.mdmarkdown1.5 KB
references/asset-sources.mdmarkdown7.9 KB
references/audit-and-red-team.mdmarkdown795 B
references/autonomous-improvement.mdmarkdown10.3 KB
references/backend-chain.mdmarkdown10.4 KB
references/bg-removal-local.mdmarkdown22.7 KB
references/build-scaffolds.mdmarkdown2.0 KB
references/capabilities/01-design-red-team-audit.mdmarkdown3.9 KB
references/capabilities/02-emotional-canvas-moodboard.mdmarkdown3.7 KB
references/capabilities/03-game-design-attribution-audit.mdmarkdown3.6 KB
references/capabilities/04-game-design-bartle-archetype-audit.mdmarkdown3.7 KB
references/capabilities/05-game-design-big-five-personality-audit.mdmarkdown3.6 KB
references/capabilities/06-game-design-brainstorm-methods.mdmarkdown3.9 KB
references/capabilities/07-game-design-core-loop-extractor.mdmarkdown3.7 KB
references/capabilities/08-game-design-craft-critique.mdmarkdown3.5 KB
references/capabilities/09-game-design-creative-unblocker.mdmarkdown3.5 KB
references/capabilities/10-game-design-design-pillars-extractor.mdmarkdown3.5 KB
references/capabilities/11-game-design-emotional-canvas.mdmarkdown3.6 KB
references/capabilities/12-game-design-failure-loop-audit.mdmarkdown3.8 KB
references/capabilities/13-game-design-fairness-frustration-audit.mdmarkdown3.6 KB
references/capabilities/14-game-design-fantasy-extractor.mdmarkdown3.6 KB
references/capabilities/15-game-design-feature-prioritization.mdmarkdown3.6 KB
references/capabilities/16-game-design-five-options.mdmarkdown3.5 KB
references/capabilities/17-game-design-flow-audit.mdmarkdown3.6 KB
references/capabilities/18-game-design-fogg-behavior-audit.mdmarkdown3.6 KB
references/capabilities/19-game-design-friction-journey-audit.mdmarkdown3.8 KB
references/capabilities/20-game-design-ftue-hero-journey-audit.mdmarkdown3.7 KB
references/capabilities/21-game-design-goal-density-and-immediacy-audit.mdmarkdown3.5 KB
references/capabilities/22-game-design-goal-framing.mdmarkdown3.5 KB
references/capabilities/23-game-design-granular-player-motivation-audit.mdmarkdown4.0 KB
references/capabilities/24-game-design-grow-design.mdmarkdown3.5 KB
references/capabilities/25-game-design-ideal-outcome-backcasting.mdmarkdown3.4 KB
references/capabilities/26-game-design-kpi-coverage-audit.mdmarkdown3.8 KB
references/capabilities/27-game-design-leaderboard-audit.mdmarkdown3.9 KB
references/capabilities/28-game-design-leaderboard-builder.mdmarkdown3.8 KB
references/capabilities/29-game-design-molyneux-lens.mdmarkdown3.5 KB
references/capabilities/30-game-design-multiplayer-feature-audit.mdmarkdown3.8 KB
references/capabilities/31-game-design-novelty-spectrum-audit.mdmarkdown3.6 KB
references/capabilities/32-game-design-one-page-design-doc.mdmarkdown3.8 KB
references/capabilities/33-game-design-one-thing-to-remove.mdmarkdown3.6 KB
references/capabilities/34-game-design-option-generation.mdmarkdown3.5 KB
references/capabilities/35-game-design-peak-end-audit.mdmarkdown3.6 KB
references/capabilities/36-game-design-perceived-randomness-audit.mdmarkdown3.7 KB
references/capabilities/37-game-design-pitch-deck-audit.mdmarkdown3.8 KB
references/capabilities/38-game-design-player-motivation-audit.mdmarkdown3.5 KB
references/capabilities/39-game-design-player-need-satisfaction-audit.mdmarkdown3.6 KB
references/capabilities/40-game-design-player-persona-extractor.mdmarkdown4.2 KB
references/capabilities/41-game-design-player-perspective-reframe.mdmarkdown3.7 KB
references/capabilities/42-game-design-player-segment-perception-audit.mdmarkdown3.6 KB
references/capabilities/43-game-design-player-values-mapper.mdmarkdown3.8 KB
references/capabilities/44-game-design-premium-pass-audit.mdmarkdown3.8 KB
references/capabilities/45-game-design-prosocial-session-chapters.mdmarkdown3.7 KB
references/capabilities/46-game-design-prototype-intent-audit.mdmarkdown3.7 KB
references/capabilities/47-game-design-prototyping-companion.mdmarkdown3.6 KB
references/capabilities/48-game-design-roadblock-reframing.mdmarkdown3.5 KB
references/capabilities/49-game-design-smart-goal-audit.mdmarkdown3.6 KB
references/capabilities/50-game-design-social-satisfaction-matrix.mdmarkdown3.7 KB
references/capabilities/51-game-design-systematizing-empathizing-audit.mdmarkdown3.6 KB
references/capabilities/52-game-design-thinking-fast-and-slow-audit.mdmarkdown3.6 KB
references/capabilities/53-game-design-transformative-reuse.mdmarkdown3.6 KB
references/capabilities/54-game-design-unknown-unknowns-prototyping.mdmarkdown3.6 KB
references/capabilities/55-game-design-zeigarnik-effect-audit.mdmarkdown3.6 KB
references/capabilities/56-game-dev-budget-estimator.mdmarkdown3.8 KB
references/capabilities/57-game-dev-first-steps.mdmarkdown3.6 KB
references/capabilities/58-game-dev-team-gap.mdmarkdown3.6 KB
references/capabilities/59-game-dev-time-estimator.mdmarkdown3.8 KB
references/capabilities/60-moodboard-generator.mdmarkdown4.0 KB
references/capabilities/61-software-team-conflict-patterns.mdmarkdown3.8 KB
references/capability-catalog.mdmarkdown18.4 KB
references/capability-map.mdmarkdown1.7 KB
references/capability-matrix.mdmarkdown12.5 KB
references/capacitor-ios.mdmarkdown7.3 KB
references/cognition-and-choice.mdmarkdown1.2 KB
references/cognitive-and-behavioral-lenses.mdmarkdown1.2 KB
references/concept-and-loop.mdmarkdown1.5 KB
references/core-loop-and-pillars.mdmarkdown835 B
references/core-patterns.mdmarkdown8.2 KB
references/cpu-systems-harmony.mdmarkdown3.4 KB
references/creative-and-options.mdmarkdown2.0 KB
references/creative-direction.mdmarkdown1.3 KB
references/deploy.mdmarkdown5.3 KB
references/design-artifacts.mdmarkdown1.0 KB
references/emotion-and-presentation.mdmarkdown1.1 KB
references/error-catalog.mdmarkdown22.6 KB
references/fairness-and-failure.mdmarkdown1.2 KB
references/fairness-and-learning.mdmarkdown1.3 KB
references/fal-ai-image.mdmarkdown7.1 KB
references/frame-detection.mdmarkdown20.0 KB
references/full-diagnostic.mdmarkdown4.2 KB
references/game-asset-generator.mdmarkdown9.5 KB
references/game-audio.mdmarkdown7.5 KB
references/game-feel-patterns.mdmarkdown12.2 KB
references/game-pipeline.mdmarkdown11.5 KB
references/game-qa.mdmarkdown6.7 KB
references/game-sprite-pipeline.mdmarkdown33.4 KB
references/gm-brilliant-implementation.mdmarkdown13.4 KB
references/grid-shapes.mdmarkdown8.0 KB
references/meshyai.mdmarkdown7.3 KB
references/motion-pipeline.mdmarkdown7.5 KB
references/output-formats.mdmarkdown9.4 KB
references/pacing-and-return.mdmarkdown1.6 KB
references/performance.mdmarkdown7.8 KB
references/phaser-gamedev.mdmarkdown7.5 KB
references/pipeline-spec.jsonconfig23.0 KB
references/pixel-art-sprites.mdmarkdown8.7 KB
references/planning-and-communication.mdmarkdown1.6 KB
references/planning-and-production.mdmarkdown1.8 KB
references/player-and-social.mdmarkdown2.3 KB
references/polish-scaffolds.mdmarkdown1.9 KB
references/progression-and-economy.mdmarkdown1.0 KB
references/promo-video.mdmarkdown6.6 KB
references/prompt-rules.mdmarkdown15.2 KB
references/quality-gates.mdmarkdown6.4 KB
references/road-to-aew-integration.mdmarkdown7.8 KB
references/social-and-competitive-design.mdmarkdown1.1 KB
references/social-and-competitive.mdmarkdown1.5 KB
references/spritesheets.mdmarkdown6.2 KB
references/stage-contracts.mdmarkdown11.1 KB
references/style-presets.mdmarkdown5.1 KB
references/subagent-delegation.mdmarkdown2.2 KB
references/tilemaps-and-physics.mdmarkdown13.6 KB
references/tilemaps.mdmarkdown7.0 KB
references/unity-batchmode-builds.mdmarkdown9.2 KB
references/unity-cli.mdmarkdown10.9 KB
references/unity-licensing.mdmarkdown5.0 KB
references/vfx-containment.mdmarkdown3.1 KB
references/workflow-dag.mdmarkdown4.1 KB
references/worldlabs.mdmarkdown7.9 KB
references/wrestler-archetypes.mdmarkdown7.2 KB
scripts/deterministic_idle.pyscript7.8 KB
scripts/fal_queue_image_run.pyscript9.4 KB
scripts/imgdiff.pyscript5.0 KB
scripts/meshy-generate.mjsscript11.1 KB
scripts/optimize-glb.mjsscript3.8 KB
scripts/portrait_pipeline.pyscript31.2 KB
scripts/qa_artifacts.pyscript14.4 KB
scripts/road_to_aew_integration.pyscript6.6 KB
scripts/row_job_status.pyscript8.6 KB
scripts/sprite_anchor.pyscript30.1 KB
scripts/sprite_assemble.pyscript16.0 KB
scripts/sprite_bg.pyscript28.5 KB
scripts/sprite_canvas.pyscript11.9 KB
scripts/sprite_generate.pyscript13.9 KB
scripts/sprite_pipeline.pyscript54.9 KB
scripts/sprite_process.pyscript13.5 KB
scripts/sprite_prompt.pyscript41.8 KB
scripts/sprite_slicing.pyscript38.7 KB
scripts/sprite_verify.pyscript58.5 KB
scripts/test_content_aware_extraction.pyscript13.4 KB
scripts/test_no_status_laundering.pyscript6.9 KB
scripts/test_phases_4_5_7_8.pyscript16.4 KB
scripts/test_pipeline_glue.pyscript20.9 KB
scripts/test_pipeline_patterns.pyscript10.9 KB
scripts/test_rc3_frames_distinct_threshold.pyscript14.2 KB
scripts/test_rc4_mass_centroid_default.pyscript8.3 KB
scripts/test_rc5_despill_pre_upscale.pyscript7.9 KB
scripts/test_slice_grid_cells.pyscript6.4 KB
scripts/test_slicer_strict_pitch_default.pyscript11.6 KB
scripts/test_verifier_cell_parity.pyscript9.0 KB
scripts/test_verify_gates.pyscript23.2 KB
scripts/tests/test_fal_queue_image_run.pyscript908 B
scripts/video_extract_frames.pyscript4.3 KB
scripts/video_process_frames.pyscript7.6 KB
scripts/video_select_frames.pyscript6.4 KB
scripts/with_server.pyscript5.8 KB

scripts/qa_artifacts.py

View on GitHub
#!/usr/bin/env python3
"""Visual QA artifact generation for the game-sprite-pipeline (Phase 7).

Produces labeled contact sheets, per-state preview GIFs, and structured
QA reports to accelerate human review of generated spritesheets.

Subcommands:
    make-contact-sheet      Labeled contact sheet from spritesheet
    render-preview-videos   Per-state animated GIFs from spritesheet
    generate-qa-report      JSON QA report with per-row metrics

Usage:
    python3 qa_artifacts.py make-contact-sheet \\
        --input sheet.png --grid 8x9 --cell-size 256 --output qa/contact.png

    python3 qa_artifacts.py render-preview-videos \\
        --input sheet.png --grid 8x9 --cell-size 256 --output-dir qa/previews/ \\
        --preset fighter

    python3 qa_artifacts.py generate-qa-report \\
        --input sheet.png --grid 8x9 --cell-size 256 --output qa/review.json \\
        --preset fighter
"""

from __future__ import annotations

import argparse
import json
import logging
import sys
from pathlib import Path

logger = logging.getLogger("sprite-pipeline.qa_artifacts")

try:
    from PIL import Image, ImageDraw, ImageFont
except ImportError as e:
    logger.error("Pillow not installed: %s", e)
    sys.exit(1)

SCRIPT_DIR = Path(__file__).resolve().parent
sys.path.insert(0, str(SCRIPT_DIR))

import sprite_bg
import sprite_prompt


def _load_font(size: int = 14) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
    """Load a font for text labels, falling back to default."""
    try:
        return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", size)
    except (OSError, IOError):
        try:
            return ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf", size)
        except (OSError, IOError):
            return ImageFont.load_default()


def _slice_cells(sheet: Image.Image, cols: int, rows: int, cell_size: int) -> list[list[Image.Image]]:
    """Slice a spritesheet into a 2D grid ``[row][col]`` of cell images."""
    grid: list[list[Image.Image]] = []
    for r in range(rows):
        row: list[Image.Image] = []
        for c in range(cols):
            x = c * cell_size
            y = r * cell_size
            cell = sheet.crop((x, y, x + cell_size, y + cell_size))
            row.append(cell)
        grid.append(row)
    return grid


def _get_state_names(preset_name: str | None, num_rows: int) -> list[str]:
    """Get state names from preset or generate default labels.

    Args:
        preset_name: Optional preset name to look up state names.
        num_rows: Number of rows to generate labels for.

    Returns:
        List of state name strings.
    """
    if preset_name:
        try:
            preset = sprite_prompt.resolve_preset(preset_name)
            return [r["state"] for r in preset["rows"][:num_rows]]
        except ValueError:
            pass
    return [f"row_{i}" for i in range(num_rows)]


def make_contact_sheet(
    input_path: Path,
    output_path: Path,
    cols: int,
    rows: int,
    cell_size: int,
    preset_name: str | None = None,
) -> Path:
    """Produce a labeled contact sheet PNG from a spritesheet.

    Args:
        input_path: Path to the spritesheet PNG.
        output_path: Path for the contact sheet output.
        cols: Number of columns in the spritesheet grid.
        rows: Number of rows in the spritesheet grid.
        cell_size: Cell size in pixels.
        preset_name: Optional preset for state name labels.

    Returns:
        Path to the generated contact sheet.
    """
    sheet = Image.open(input_path).convert("RGBA")
    grid = _slice_cells(sheet, cols, rows, cell_size)
    state_names = _get_state_names(preset_name, rows)

    # Layout: label column + cell thumbnails
    thumb_size = min(cell_size, 128)
    label_width = 140
    padding = 4
    header_height = 24

    out_w = label_width + cols * (thumb_size + padding) + padding
    out_h = header_height + rows * (thumb_size + padding) + padding

    canvas = Image.new("RGBA", (out_w, out_h), (32, 32, 32, 255))
    draw = ImageDraw.Draw(canvas)
    font = _load_font(12)
    header_font = _load_font(11)

    # Column headers
    for c in range(cols):
        x = label_width + c * (thumb_size + padding) + padding
        draw.text((x + 2, 4), f"F{c}", fill=(180, 180, 180, 255), font=header_font)

    # Rows
    for r in range(rows):
        y = header_height + r * (thumb_size + padding) + padding
        # Row label
        label = state_names[r] if r < len(state_names) else f"row_{r}"
        draw.text((4, y + thumb_size // 2 - 6), label, fill=(220, 220, 220, 255), font=font)

        for c in range(cols):
            x = label_width + c * (thumb_size + padding) + padding
            cell = grid[r][c].copy()
            cell.thumbnail((thumb_size, thumb_size), Image.Resampling.LANCZOS)

            # Composite cell over dark background for visibility
            bg = Image.new("RGBA", (thumb_size, thumb_size), (48, 48, 48, 255))
            bg.paste(cell, ((thumb_size - cell.width) // 2, (thumb_size - cell.height) // 2), cell)
            canvas.paste(bg, (x, y))

            # Frame number overlay
            draw.text((x + 2, y + 2), str(c), fill=(255, 255, 100, 200), font=header_font)

    output_path.parent.mkdir(parents=True, exist_ok=True)
    canvas.save(output_path, format="PNG")
    logger.info("[qa] Contact sheet: %dx%d -> %s", cols, rows, output_path)
    return output_path


def render_preview_videos(
    input_path: Path,
    output_dir: Path,
    cols: int,
    rows: int,
    cell_size: int,
    preset_name: str | None = None,
    fps: int = 10,
) -> list[Path]:
    """Produce one animated GIF per animation state row.

    Args:
        input_path: Path to the spritesheet PNG.
        output_dir: Directory for preview GIF outputs.
        cols: Number of columns in the spritesheet grid.
        rows: Number of rows in the spritesheet grid.
        cell_size: Cell size in pixels.
        preset_name: Optional preset for state names and timing.
        fps: Default FPS when preset timing is unavailable.

    Returns:
        List of paths to generated GIFs.
    """
    sheet = Image.open(input_path).convert("RGBA")
    grid = _slice_cells(sheet, cols, rows, cell_size)
    state_names = _get_state_names(preset_name, rows)

    # Load timing from preset if available
    timing: dict[str, list[int]] = {}
    if preset_name:
        try:
            preset = sprite_prompt.resolve_preset(preset_name)
            for row_def in preset["rows"]:
                if "timing" in row_def:
                    timing[row_def["state"]] = row_def["timing"]
        except ValueError:
            pass

    output_dir.mkdir(parents=True, exist_ok=True)
    default_duration = int(1000 / max(fps, 1))
    gif_paths: list[Path] = []

    for r in range(rows):
        state = state_names[r] if r < len(state_names) else f"row_{r}"
        row_frames = grid[r]

        # Filter out empty cells (all transparent)
        valid_frames: list[Image.Image] = []
        for cell in row_frames:
            bbox = cell.getbbox()
            if bbox is not None:
                valid_frames.append(cell)

        if not valid_frames:
            continue

        # Per-frame durations from preset timing
        state_timing = timing.get(state)
        if state_timing and len(state_timing) >= len(valid_frames):
            durations = state_timing[: len(valid_frames)]
        else:
            durations = [default_duration] * len(valid_frames)

        # Matte composite for GIF
        gif_frames = [
            sprite_bg.matte_composite(f, matte=(40, 40, 40)).convert("P", palette=Image.Palette.ADAPTIVE)
            for f in valid_frames
        ]

        gif_path = output_dir / f"{state}.gif"
        gif_frames[0].save(
            gif_path,
            save_all=True,
            append_images=gif_frames[1:],
            duration=durations,
            loop=0,
            disposal=2,
        )
        gif_paths.append(gif_path)
        logger.info("[qa] Preview GIF: %s (%d frames) -> %s", state, len(valid_frames), gif_path)

    return gif_paths


def generate_qa_report(
    input_path: Path,
    output_path: Path,
    cols: int,
    rows: int,
    cell_size: int,
    preset_name: str | None = None,
) -> dict:
    """Produce a QA report JSON with per-row metrics.

    Args:
        input_path: Path to the spritesheet PNG.
        output_path: Path for the QA report JSON.
        cols: Number of columns in the spritesheet grid.
        rows: Number of rows in the spritesheet grid.
        cell_size: Cell size in pixels.
        preset_name: Optional preset for expected frame counts.

    Returns:
        QA report dict.
    """
    sheet = Image.open(input_path).convert("RGBA")
    grid = _slice_cells(sheet, cols, rows, cell_size)
    state_names = _get_state_names(preset_name, rows)

    # Get expected frame counts from preset
    expected_frames: dict[str, int] = {}
    if preset_name:
        try:
            preset = sprite_prompt.resolve_preset(preset_name)
            for row_def in preset["rows"]:
                expected_frames[row_def["state"]] = row_def["frames"]
        except ValueError:
            pass

    row_reports = []
    for r in range(rows):
        state = state_names[r] if r < len(state_names) else f"row_{r}"
        row_frames = grid[r]

        # Count non-empty frames
        actual_count = 0
        for cell in row_frames:
            if cell.getbbox() is not None:
                actual_count += 1

        expected = expected_frames.get(state, cols)
        frame_match = actual_count == expected

        row_reports.append(
            {
                "row_index": r,
                "state": state,
                "frame_count": {
                    "actual": actual_count,
                    "expected": expected,
                    "match": frame_match,
                },
                "identity_consistency": "visual inspection required",
                "effects_compliance": "visual inspection required",
                "overall_status": "pass" if frame_match else "review",
            }
        )

    overall_pass = all(rr["overall_status"] == "pass" for rr in row_reports)
    report = {
        "spritesheet": str(input_path),
        "grid": f"{cols}x{rows}",
        "cell_size": cell_size,
        "preset": preset_name,
        "overall_status": "pass" if overall_pass else "review",
        "rows": row_reports,
    }

    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(report, indent=2), encoding="utf-8")
    logger.info("[qa] Report: %s -> %s", "PASS" if overall_pass else "REVIEW", output_path)
    return report


# ---------------------------------------------------------------------------
# CLI subcommands
# ---------------------------------------------------------------------------
def _parse_grid(grid: str) -> tuple[int, int]:
    """Parse grid spec 'CxR' into (cols, rows)."""
    parts = grid.split("x")
    if len(parts) != 2:
        raise ValueError(f"Invalid grid format {grid!r}. Use CxR like '8x9'.")
    return int(parts[0]), int(parts[1])


def cmd_make_contact_sheet(args: argparse.Namespace) -> int:
    """make-contact-sheet subcommand."""
    cols, rows = _parse_grid(args.grid)
    result = make_contact_sheet(
        input_path=Path(args.input),
        output_path=Path(args.output),
        cols=cols,
        rows=rows,
        cell_size=args.cell_size,
        preset_name=args.preset,
    )
    print(f"Contact sheet -> {result}")
    return 0


def cmd_render_preview_videos(args: argparse.Namespace) -> int:
    """render-preview-videos subcommand."""
    cols, rows = _parse_grid(args.grid)
    paths = render_preview_videos(
        input_path=Path(args.input),
        output_dir=Path(args.output_dir),
        cols=cols,
        rows=rows,
        cell_size=args.cell_size,
        preset_name=args.preset,
        fps=args.fps,
    )
    print(f"Generated {len(paths)} preview GIFs")
    return 0


def cmd_generate_qa_report(args: argparse.Namespace) -> int:
    """generate-qa-report subcommand."""
    cols, rows = _parse_grid(args.grid)
    report = generate_qa_report(
        input_path=Path(args.input),
        output_path=Path(args.output),
        cols=cols,
        rows=rows,
        cell_size=args.cell_size,
        preset_name=args.preset,
    )
    print(json.dumps(report, indent=2))
    return 0


def build_parser() -> argparse.ArgumentParser:
    """Build the CLI parser."""
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = parser.add_subparsers(dest="cmd", required=True)

    cs = sub.add_parser("make-contact-sheet", help="Labeled contact sheet from spritesheet")
    cs.add_argument("--input", required=True, help="Spritesheet PNG path")
    cs.add_argument("--grid", required=True, help="Grid CxR (e.g., 8x9)")
    cs.add_argument("--cell-size", type=int, default=256)
    cs.add_argument("--output", required=True, help="Output contact sheet PNG path")
    cs.add_argument("--preset", help="Preset name for state labels")
    cs.set_defaults(func=cmd_make_contact_sheet)

    pv = sub.add_parser("render-preview-videos", help="Per-state animated GIFs")
    pv.add_argument("--input", required=True, help="Spritesheet PNG path")
    pv.add_argument("--grid", required=True, help="Grid CxR (e.g., 8x9)")
    pv.add_argument("--cell-size", type=int, default=256)
    pv.add_argument("--output-dir", required=True, help="Output directory for GIFs")
    pv.add_argument("--preset", help="Preset name for state names and timing")
    pv.add_argument("--fps", type=int, default=10, help="Default FPS (overridden by preset timing)")
    pv.set_defaults(func=cmd_render_preview_videos)

    qr = sub.add_parser("generate-qa-report", help="JSON QA report")
    qr.add_argument("--input", required=True, help="Spritesheet PNG path")
    qr.add_argument("--grid", required=True, help="Grid CxR (e.g., 8x9)")
    qr.add_argument("--cell-size", type=int, default=256)
    qr.add_argument("--output", required=True, help="Output review.json path")
    qr.add_argument("--preset", help="Preset name for expected frame counts")
    qr.set_defaults(func=cmd_generate_qa_report)

    return parser


def main(argv: list[str] | None = None) -> int:
    """CLI entry point."""
    if not logging.getLogger().handlers:
        logging.basicConfig(
            level=logging.INFO,
            format="[%(name)s] %(levelname)s: %(message)s",
            stream=sys.stderr,
        )
    parser = build_parser()
    args = parser.parse_args(argv)
    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 321kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 197kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall