@papert-code/papert-code 0.3.94 → 0.3.96

package/dist/skills/slack-gif-creator/SKILL.md

@@ -0,0 +1,254 @@
+---
+name: slack-gif-creator
+description: Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."
+license: Complete terms in LICENSE.txt
+---
+
+# Slack GIF Creator
+
+A toolkit providing utilities and knowledge for creating animated GIFs optimized for Slack.
+
+## Slack Requirements
+
+**Dimensions:**
+- Emoji GIFs: 128x128 (recommended)
+- Message GIFs: 480x480
+
+**Parameters:**
+- FPS: 10-30 (lower is smaller file size)
+- Colors: 48-128 (fewer = smaller file size)
+- Duration: Keep under 3 seconds for emoji GIFs
+
+## Core Workflow
+
+```python
+from core.gif_builder import GIFBuilder
+from PIL import Image, ImageDraw
+
+# 1. Create builder
+builder = GIFBuilder(width=128, height=128, fps=10)
+
+# 2. Generate frames
+for i in range(12):
+    frame = Image.new('RGB', (128, 128), (240, 248, 255))
+    draw = ImageDraw.Draw(frame)
+
+    # Draw your animation using PIL primitives
+    # (circles, polygons, lines, etc.)
+
+    builder.add_frame(frame)
+
+# 3. Save with optimization
+builder.save('output.gif', num_colors=48, optimize_for_emoji=True)
+```
+
+## Drawing Graphics
+
+### Working with User-Uploaded Images
+If a user uploads an image, consider whether they want to:
+- **Use it directly** (e.g., "animate this", "split this into frames")
+- **Use it as inspiration** (e.g., "make something like this")
+
+Load and work with images using PIL:
+```python
+from PIL import Image
+
+uploaded = Image.open('file.png')
+# Use directly, or just as reference for colors/style
+```
+
+### Drawing from Scratch
+When drawing graphics from scratch, use PIL ImageDraw primitives:
+
+```python
+from PIL import ImageDraw
+
+draw = ImageDraw.Draw(frame)
+
+# Circles/ovals
+draw.ellipse([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)
+
+# Stars, triangles, any polygon
+points = [(x1, y1), (x2, y2), (x3, y3), ...]
+draw.polygon(points, fill=(r, g, b), outline=(r, g, b), width=3)
+
+# Lines
+draw.line([(x1, y1), (x2, y2)], fill=(r, g, b), width=5)
+
+# Rectangles
+draw.rectangle([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)
+```
+
+**Don't use:** Emoji fonts (unreliable across platforms) or assume pre-packaged graphics exist in this skill.
+
+### Making Graphics Look Good
+
+Graphics should look polished and creative, not basic. Here's how:
+
+**Use thicker lines** - Always set `width=2` or higher for outlines and lines. Thin lines (width=1) look choppy and amateurish.
+
+**Add visual depth**:
+- Use gradients for backgrounds (`create_gradient_background`)
+- Layer multiple shapes for complexity (e.g., a star with a smaller star inside)
+
+**Make shapes more interesting**:
+- Don't just draw a plain circle - add highlights, rings, or patterns
+- Stars can have glows (draw larger, semi-transparent versions behind)
+- Combine multiple shapes (stars + sparkles, circles + rings)
+
+**Pay attention to colors**:
+- Use vibrant, complementary colors
+- Add contrast (dark outlines on light shapes, light outlines on dark shapes)
+- Consider the overall composition
+
+**For complex shapes** (hearts, snowflakes, etc.):
+- Use combinations of polygons and ellipses
+- Calculate points carefully for symmetry
+- Add details (a heart can have a highlight curve, snowflakes have intricate branches)
+
+Be creative and detailed! A good Slack GIF should look polished, not like placeholder graphics.
+
+## Available Utilities
+
+### GIFBuilder (`core.gif_builder`)
+Assembles frames and optimizes for Slack:
+```python
+builder = GIFBuilder(width=128, height=128, fps=10)
+builder.add_frame(frame)  # Add PIL Image
+builder.add_frames(frames)  # Add list of frames
+builder.save('out.gif', num_colors=48, optimize_for_emoji=True, remove_duplicates=True)
+```
+
+### Validators (`core.validators`)
+Check if GIF meets Slack requirements:
+```python
+from core.validators import validate_gif, is_slack_ready
+
+# Detailed validation
+passes, info = validate_gif('my.gif', is_emoji=True, verbose=True)
+
+# Quick check
+if is_slack_ready('my.gif'):
+    print("Ready!")
+```
+
+### Easing Functions (`core.easing`)
+Smooth motion instead of linear:
+```python
+from core.easing import interpolate
+
+# Progress from 0.0 to 1.0
+t = i / (num_frames - 1)
+
+# Apply easing
+y = interpolate(start=0, end=400, t=t, easing='ease_out')
+
+# Available: linear, ease_in, ease_out, ease_in_out,
+#           bounce_out, elastic_out, back_out
+```
+
+### Frame Helpers (`core.frame_composer`)
+Convenience functions for common needs:
+```python
+from core.frame_composer import (
+    create_blank_frame,         # Solid color background
+    create_gradient_background,  # Vertical gradient
+    draw_circle,                # Helper for circles
+    draw_text,                  # Simple text rendering
+    draw_star                   # 5-pointed star
+)
+```
+
+## Animation Concepts
+
+### Shake/Vibrate
+Offset object position with oscillation:
+- Use `math.sin()` or `math.cos()` with frame index
+- Add small random variations for natural feel
+- Apply to x and/or y position
+
+### Pulse/Heartbeat
+Scale object size rhythmically:
+- Use `math.sin(t * frequency * 2 * math.pi)` for smooth pulse
+- For heartbeat: two quick pulses then pause (adjust sine wave)
+- Scale between 0.8 and 1.2 of base size
+
+### Bounce
+Object falls and bounces:
+- Use `interpolate()` with `easing='bounce_out'` for landing
+- Use `easing='ease_in'` for falling (accelerating)
+- Apply gravity by increasing y velocity each frame
+
+### Spin/Rotate
+Rotate object around center:
+- PIL: `image.rotate(angle, resample=Image.BICUBIC)`
+- For wobble: use sine wave for angle instead of linear
+
+### Fade In/Out
+Gradually appear or disappear:
+- Create RGBA image, adjust alpha channel
+- Or use `Image.blend(image1, image2, alpha)`
+- Fade in: alpha from 0 to 1
+- Fade out: alpha from 1 to 0
+
+### Slide
+Move object from off-screen to position:
+- Start position: outside frame bounds
+- End position: target location
+- Use `interpolate()` with `easing='ease_out'` for smooth stop
+- For overshoot: use `easing='back_out'`
+
+### Zoom
+Scale and position for zoom effect:
+- Zoom in: scale from 0.1 to 2.0, crop center
+- Zoom out: scale from 2.0 to 1.0
+- Can add motion blur for drama (PIL filter)
+
+### Explode/Particle Burst
+Create particles radiating outward:
+- Generate particles with random angles and velocities
+- Update each particle: `x += vx`, `y += vy`
+- Add gravity: `vy += gravity_constant`
+- Fade out particles over time (reduce alpha)
+
+## Optimization Strategies
+
+Only when asked to make the file size smaller, implement a few of the following methods:
+
+1. **Fewer frames** - Lower FPS (10 instead of 20) or shorter duration
+2. **Fewer colors** - `num_colors=48` instead of 128
+3. **Smaller dimensions** - 128x128 instead of 480x480
+4. **Remove duplicates** - `remove_duplicates=True` in save()
+5. **Emoji mode** - `optimize_for_emoji=True` auto-optimizes
+
+```python
+# Maximum optimization for emoji
+builder.save(
+    'emoji.gif',
+    num_colors=48,
+    optimize_for_emoji=True,
+    remove_duplicates=True
+)
+```
+
+## Philosophy
+
+This skill provides:
+- **Knowledge**: Slack's requirements and animation concepts
+- **Utilities**: GIFBuilder, validators, easing functions
+- **Flexibility**: Create the animation logic using PIL primitives
+
+It does NOT provide:
+- Rigid animation templates or pre-made functions
+- Emoji font rendering (unreliable across platforms)
+- A library of pre-packaged graphics built into the skill
+
+**Note on user uploads**: This skill doesn't include pre-built graphics, but if a user uploads an image, use PIL to load and work with it - interpret based on their request whether they want it used directly or just as inspiration.
+
+Be creative! Combine concepts (bouncing + rotating, pulsing + sliding, etc.) and use PIL's full capabilities.
+
+## Dependencies
+
+```bash
+pip install pillow imageio numpy
+```

package/dist/skills/slack-gif-creator/core/easing.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Easing Functions - Timing functions for smooth animations.
+
+Provides various easing functions for natural motion and timing.
+All functions take a value t (0.0 to 1.0) and return eased value (0.0 to 1.0).
+"""
+
+import math
+
+
+def linear(t: float) -> float:
+    """Linear interpolation (no easing)."""
+    return t
+
+
+def ease_in_quad(t: float) -> float:
+    """Quadratic ease-in (slow start, accelerating)."""
+    return t * t
+
+
+def ease_out_quad(t: float) -> float:
+    """Quadratic ease-out (fast start, decelerating)."""
+    return t * (2 - t)
+
+
+def ease_in_out_quad(t: float) -> float:
+    """Quadratic ease-in-out (slow start and end)."""
+    if t < 0.5:
+        return 2 * t * t
+    return -1 + (4 - 2 * t) * t
+
+
+def ease_in_cubic(t: float) -> float:
+    """Cubic ease-in (slow start)."""
+    return t * t * t
+
+
+def ease_out_cubic(t: float) -> float:
+    """Cubic ease-out (fast start)."""
+    return (t - 1) * (t - 1) * (t - 1) + 1
+
+
+def ease_in_out_cubic(t: float) -> float:
+    """Cubic ease-in-out."""
+    if t < 0.5:
+        return 4 * t * t * t
+    return (t - 1) * (2 * t - 2) * (2 * t - 2) + 1
+
+
+def ease_in_bounce(t: float) -> float:
+    """Bounce ease-in (bouncy start)."""
+    return 1 - ease_out_bounce(1 - t)
+
+
+def ease_out_bounce(t: float) -> float:
+    """Bounce ease-out (bouncy end)."""
+    if t < 1 / 2.75:
+        return 7.5625 * t * t
+    elif t < 2 / 2.75:
+        t -= 1.5 / 2.75
+        return 7.5625 * t * t + 0.75
+    elif t < 2.5 / 2.75:
+        t -= 2.25 / 2.75
+        return 7.5625 * t * t + 0.9375
+    else:
+        t -= 2.625 / 2.75
+        return 7.5625 * t * t + 0.984375
+
+
+def ease_in_out_bounce(t: float) -> float:
+    """Bounce ease-in-out."""
+    if t < 0.5:
+        return ease_in_bounce(t * 2) * 0.5
+    return ease_out_bounce(t * 2 - 1) * 0.5 + 0.5
+
+
+def ease_in_elastic(t: float) -> float:
+    """Elastic ease-in (spring effect)."""
+    if t == 0 or t == 1:
+        return t
+    return -math.pow(2, 10 * (t - 1)) * math.sin((t - 1.1) * 5 * math.pi)
+
+
+def ease_out_elastic(t: float) -> float:
+    """Elastic ease-out (spring effect)."""
+    if t == 0 or t == 1:
+        return t
+    return math.pow(2, -10 * t) * math.sin((t - 0.1) * 5 * math.pi) + 1
+
+
+def ease_in_out_elastic(t: float) -> float:
+    """Elastic ease-in-out."""
+    if t == 0 or t == 1:
+        return t
+    t = t * 2 - 1
+    if t < 0:
+        return -0.5 * math.pow(2, 10 * t) * math.sin((t - 0.1) * 5 * math.pi)
+    return math.pow(2, -10 * t) * math.sin((t - 0.1) * 5 * math.pi) * 0.5 + 1
+
+
+# Convenience mapping
+EASING_FUNCTIONS = {
+    "linear": linear,
+    "ease_in": ease_in_quad,
+    "ease_out": ease_out_quad,
+    "ease_in_out": ease_in_out_quad,
+    "bounce_in": ease_in_bounce,
+    "bounce_out": ease_out_bounce,
+    "bounce": ease_in_out_bounce,
+    "elastic_in": ease_in_elastic,
+    "elastic_out": ease_out_elastic,
+    "elastic": ease_in_out_elastic,
+}
+
+
+def get_easing(name: str = "linear"):
+    """Get easing function by name."""
+    return EASING_FUNCTIONS.get(name, linear)
+
+
+def interpolate(start: float, end: float, t: float, easing: str = "linear") -> float:
+    """
+    Interpolate between two values with easing.
+
+    Args:
+        start: Start value
+        end: End value
+        t: Progress from 0.0 to 1.0
+        easing: Name of easing function
+
+    Returns:
+        Interpolated value
+    """
+    ease_func = get_easing(easing)
+    eased_t = ease_func(t)
+    return start + (end - start) * eased_t
+
+
+def ease_back_in(t: float) -> float:
+    """Back ease-in (slight overshoot backward before forward motion)."""
+    c1 = 1.70158
+    c3 = c1 + 1
+    return c3 * t * t * t - c1 * t * t
+
+
+def ease_back_out(t: float) -> float:
+    """Back ease-out (overshoot forward then settle back)."""
+    c1 = 1.70158
+    c3 = c1 + 1
+    return 1 + c3 * pow(t - 1, 3) + c1 * pow(t - 1, 2)
+
+
+def ease_back_in_out(t: float) -> float:
+    """Back ease-in-out (overshoot at both ends)."""
+    c1 = 1.70158
+    c2 = c1 * 1.525
+    if t < 0.5:
+        return (pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2
+    return (pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2
+
+
+def apply_squash_stretch(
+    base_scale: tuple[float, float], intensity: float, direction: str = "vertical"
+) -> tuple[float, float]:
+    """
+    Calculate squash and stretch scales for more dynamic animation.
+
+    Args:
+        base_scale: (width_scale, height_scale) base scales
+        intensity: Squash/stretch intensity (0.0-1.0)
+        direction: 'vertical', 'horizontal', or 'both'
+
+    Returns:
+        (width_scale, height_scale) with squash/stretch applied
+    """
+    width_scale, height_scale = base_scale
+
+    if direction == "vertical":
+        # Compress vertically, expand horizontally (preserve volume)
+        height_scale *= 1 - intensity * 0.5
+        width_scale *= 1 + intensity * 0.5
+    elif direction == "horizontal":
+        # Compress horizontally, expand vertically
+        width_scale *= 1 - intensity * 0.5
+        height_scale *= 1 + intensity * 0.5
+    elif direction == "both":
+        # General squash (both dimensions)
+        width_scale *= 1 - intensity * 0.3
+        height_scale *= 1 - intensity * 0.3
+
+    return (width_scale, height_scale)
+
+
+def calculate_arc_motion(
+    start: tuple[float, float], end: tuple[float, float], height: float, t: float
+) -> tuple[float, float]:
+    """
+    Calculate position along a parabolic arc (natural motion path).
+
+    Args:
+        start: (x, y) starting position
+        end: (x, y) ending position
+        height: Arc height at midpoint (positive = upward)
+        t: Progress (0.0-1.0)
+
+    Returns:
+        (x, y) position along arc
+    """
+    x1, y1 = start
+    x2, y2 = end
+
+    # Linear interpolation for x
+    x = x1 + (x2 - x1) * t
+
+    # Parabolic interpolation for y
+    # y = start + progress * (end - start) + arc_offset
+    # Arc offset peaks at t=0.5
+    arc_offset = 4 * height * t * (1 - t)
+    y = y1 + (y2 - y1) * t - arc_offset
+
+    return (x, y)
+
+
+# Add new easing functions to the convenience mapping
+EASING_FUNCTIONS.update(
+    {
+        "back_in": ease_back_in,
+        "back_out": ease_back_out,
+        "back_in_out": ease_back_in_out,
+        "anticipate": ease_back_in,  # Alias
+        "overshoot": ease_back_out,  # Alias
+    }
+)

package/dist/skills/slack-gif-creator/core/frame_composer.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Frame Composer - Utilities for composing visual elements into frames.
+
+Provides functions for drawing shapes, text, emojis, and compositing elements
+together to create animation frames.
+"""
+
+from typing import Optional
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+
+def create_blank_frame(
+    width: int, height: int, color: tuple[int, int, int] = (255, 255, 255)
+) -> Image.Image:
+    """
+    Create a blank frame with solid color background.
+
+    Args:
+        width: Frame width
+        height: Frame height
+        color: RGB color tuple (default: white)
+
+    Returns:
+        PIL Image
+    """
+    return Image.new("RGB", (width, height), color)
+
+
+def draw_circle(
+    frame: Image.Image,
+    center: tuple[int, int],
+    radius: int,
+    fill_color: Optional[tuple[int, int, int]] = None,
+    outline_color: Optional[tuple[int, int, int]] = None,
+    outline_width: int = 1,
+) -> Image.Image:
+    """
+    Draw a circle on a frame.
+
+    Args:
+        frame: PIL Image to draw on
+        center: (x, y) center position
+        radius: Circle radius
+        fill_color: RGB fill color (None for no fill)
+        outline_color: RGB outline color (None for no outline)
+        outline_width: Outline width in pixels
+
+    Returns:
+        Modified frame
+    """
+    draw = ImageDraw.Draw(frame)
+    x, y = center
+    bbox = [x - radius, y - radius, x + radius, y + radius]
+    draw.ellipse(bbox, fill=fill_color, outline=outline_color, width=outline_width)
+    return frame
+
+
+def draw_text(
+    frame: Image.Image,
+    text: str,
+    position: tuple[int, int],
+    color: tuple[int, int, int] = (0, 0, 0),
+    centered: bool = False,
+) -> Image.Image:
+    """
+    Draw text on a frame.
+
+    Args:
+        frame: PIL Image to draw on
+        text: Text to draw
+        position: (x, y) position (top-left unless centered=True)
+        color: RGB text color
+        centered: If True, center text at position
+
+    Returns:
+        Modified frame
+    """
+    draw = ImageDraw.Draw(frame)
+
+    # Uses Pillow's default font.
+    # If the font should be changed for the emoji, add additional logic here.
+    font = ImageFont.load_default()
+
+    if centered:
+        bbox = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        x = position[0] - text_width // 2
+        y = position[1] - text_height // 2
+        position = (x, y)
+
+    draw.text(position, text, fill=color, font=font)
+    return frame
+
+
+def create_gradient_background(
+    width: int,
+    height: int,
+    top_color: tuple[int, int, int],
+    bottom_color: tuple[int, int, int],
+) -> Image.Image:
+    """
+    Create a vertical gradient background.
+
+    Args:
+        width: Frame width
+        height: Frame height
+        top_color: RGB color at top
+        bottom_color: RGB color at bottom
+
+    Returns:
+        PIL Image with gradient
+    """
+    frame = Image.new("RGB", (width, height))
+    draw = ImageDraw.Draw(frame)
+
+    # Calculate color step for each row
+    r1, g1, b1 = top_color
+    r2, g2, b2 = bottom_color
+
+    for y in range(height):
+        # Interpolate color
+        ratio = y / height
+        r = int(r1 * (1 - ratio) + r2 * ratio)
+        g = int(g1 * (1 - ratio) + g2 * ratio)
+        b = int(b1 * (1 - ratio) + b2 * ratio)
+
+        # Draw horizontal line
+        draw.line([(0, y), (width, y)], fill=(r, g, b))
+
+    return frame
+
+
+def draw_star(
+    frame: Image.Image,
+    center: tuple[int, int],
+    size: int,
+    fill_color: tuple[int, int, int],
+    outline_color: Optional[tuple[int, int, int]] = None,
+    outline_width: int = 1,
+) -> Image.Image:
+    """
+    Draw a 5-pointed star.
+
+    Args:
+        frame: PIL Image to draw on
+        center: (x, y) center position
+        size: Star size (outer radius)
+        fill_color: RGB fill color
+        outline_color: RGB outline color (None for no outline)
+        outline_width: Outline width
+
+    Returns:
+        Modified frame
+    """
+    import math
+
+    draw = ImageDraw.Draw(frame)
+    x, y = center
+
+    # Calculate star points
+    points = []
+    for i in range(10):
+        angle = (i * 36 - 90) * math.pi / 180  # 36 degrees per point, start at top
+        radius = size if i % 2 == 0 else size * 0.4  # Alternate between outer and inner
+        px = x + radius * math.cos(angle)
+        py = y + radius * math.sin(angle)
+        points.append((px, py))
+
+    # Draw star
+    draw.polygon(points, fill=fill_color, outline=outline_color, width=outline_width)
+
+    return frame