@amrhas82/agentic-kit 1.7.0 → 1.7.5

package/packages/opencode/command/slack-gif-creator/core/easing.py

@@ -1,230 +0,0 @@
-#!/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/packages/opencode/command/slack-gif-creator/core/frame_composer.py

@@ -1,469 +0,0 @@
-#!/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 PIL import Image, ImageDraw, ImageFont
-import numpy as np
-from typing import Optional
-
-
-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_rectangle(frame: Image.Image, top_left: tuple[int, int], bottom_right: tuple[int, 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 rectangle on a frame.
-
-    Args:
-        frame: PIL Image to draw on
-        top_left: (x, y) top-left corner
-        bottom_right: (x, y) bottom-right corner
-        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)
-    draw.rectangle([top_left, bottom_right], fill=fill_color, outline=outline_color, width=outline_width)
-    return frame
-
-
-def draw_line(frame: Image.Image, start: tuple[int, int], end: tuple[int, int],
-              color: tuple[int, int, int] = (0, 0, 0), width: int = 2) -> Image.Image:
-    """
-    Draw a line on a frame.
-
-    Args:
-        frame: PIL Image to draw on
-        start: (x, y) start position
-        end: (x, y) end position
-        color: RGB line color
-        width: Line width in pixels
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    draw.line([start, end], fill=color, width=width)
-    return frame
-
-
-def draw_text(frame: Image.Image, text: str, position: tuple[int, int],
-              font_size: int = 40, 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)
-        font_size: Font size in pixels
-        color: RGB text color
-        centered: If True, center text at position
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-
-    # Try to use default font, fall back to basic if not available
-    try:
-        font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", font_size)
-    except:
-        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 draw_emoji(frame: Image.Image, emoji: str, position: tuple[int, int], size: int = 60) -> Image.Image:
-    """
-    Draw emoji text on a frame (requires system emoji support).
-
-    Args:
-        frame: PIL Image to draw on
-        emoji: Emoji character(s)
-        position: (x, y) position
-        size: Emoji size in pixels
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-
-    # Use Apple Color Emoji font on macOS
-    try:
-        font = ImageFont.truetype("/System/Library/Fonts/Apple Color Emoji.ttc", size)
-    except:
-        # Fallback to text-based emoji
-        font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", size)
-
-    draw.text(position, emoji, font=font, embedded_color=True)
-    return frame
-
-
-def composite_layers(base: Image.Image, overlay: Image.Image,
-                     position: tuple[int, int] = (0, 0), alpha: float = 1.0) -> Image.Image:
-    """
-    Composite one image on top of another.
-
-    Args:
-        base: Base image
-        overlay: Image to overlay on top
-        position: (x, y) position to place overlay
-        alpha: Opacity of overlay (0.0 = transparent, 1.0 = opaque)
-
-    Returns:
-        Composite image
-    """
-    # Convert to RGBA for transparency support
-    base_rgba = base.convert('RGBA')
-    overlay_rgba = overlay.convert('RGBA')
-
-    # Apply alpha
-    if alpha < 1.0:
-        overlay_rgba = overlay_rgba.copy()
-        overlay_rgba.putalpha(int(255 * alpha))
-
-    # Paste overlay onto base
-    base_rgba.paste(overlay_rgba, position, overlay_rgba)
-
-    # Convert back to RGB
-    return base_rgba.convert('RGB')
-
-
-def draw_stick_figure(frame: Image.Image, position: tuple[int, int], scale: float = 1.0,
-                      color: tuple[int, int, int] = (0, 0, 0), line_width: int = 3) -> Image.Image:
-    """
-    Draw a simple stick figure.
-
-    Args:
-        frame: PIL Image to draw on
-        position: (x, y) center position of head
-        scale: Size multiplier
-        color: RGB line color
-        line_width: Line width in pixels
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    x, y = position
-
-    # Scale dimensions
-    head_radius = int(15 * scale)
-    body_length = int(40 * scale)
-    arm_length = int(25 * scale)
-    leg_length = int(35 * scale)
-    leg_spread = int(15 * scale)
-
-    # Head
-    draw.ellipse([x - head_radius, y - head_radius, x + head_radius, y + head_radius],
-                 outline=color, width=line_width)
-
-    # Body
-    body_start = y + head_radius
-    body_end = body_start + body_length
-    draw.line([(x, body_start), (x, body_end)], fill=color, width=line_width)
-
-    # Arms
-    arm_y = body_start + int(body_length * 0.3)
-    draw.line([(x - arm_length, arm_y), (x + arm_length, arm_y)], fill=color, width=line_width)
-
-    # Legs
-    draw.line([(x, body_end), (x - leg_spread, body_end + leg_length)], fill=color, width=line_width)
-    draw.line([(x, body_end), (x + leg_spread, body_end + leg_length)], fill=color, width=line_width)
-
-    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_emoji_enhanced(frame: Image.Image, emoji: str, position: tuple[int, int],
-                       size: int = 60, shadow: bool = True,
-                       shadow_offset: tuple[int, int] = (2, 2)) -> Image.Image:
-    """
-    Draw emoji with optional shadow for better visual quality.
-
-    Args:
-        frame: PIL Image to draw on
-        emoji: Emoji character(s)
-        position: (x, y) position
-        size: Emoji size in pixels (minimum 12)
-        shadow: Whether to add drop shadow
-        shadow_offset: Shadow offset
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-
-    # Ensure minimum size to avoid font rendering errors
-    size = max(12, size)
-
-    # Use Apple Color Emoji font on macOS
-    try:
-        font = ImageFont.truetype("/System/Library/Fonts/Apple Color Emoji.ttc", size)
-    except:
-        # Fallback to text-based emoji
-        try:
-            font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", size)
-        except:
-            font = ImageFont.load_default()
-
-    # Draw shadow first if enabled
-    if shadow and size >= 20:  # Only draw shadow for larger emojis
-        shadow_pos = (position[0] + shadow_offset[0], position[1] + shadow_offset[1])
-        # Draw semi-transparent shadow (simulated by drawing multiple times)
-        for offset in range(1, 3):
-            try:
-                draw.text((shadow_pos[0] + offset, shadow_pos[1] + offset),
-                         emoji, font=font, embedded_color=True, fill=(0, 0, 0, 100))
-            except:
-                pass  # Skip shadow if it fails
-
-    # Draw main emoji
-    try:
-        draw.text(position, emoji, font=font, embedded_color=True)
-    except:
-        # Fallback to basic drawing if embedded color fails
-        draw.text(position, emoji, font=font, fill=(0, 0, 0))
-
-    return frame
-
-
-def draw_circle_with_shadow(frame: Image.Image, center: tuple[int, int], radius: int,
-                            fill_color: tuple[int, int, int],
-                            shadow_offset: tuple[int, int] = (3, 3),
-                            shadow_color: tuple[int, int, int] = (0, 0, 0)) -> Image.Image:
-    """
-    Draw a circle with drop shadow.
-
-    Args:
-        frame: PIL Image to draw on
-        center: (x, y) center position
-        radius: Circle radius
-        fill_color: RGB fill color
-        shadow_offset: (x, y) shadow offset
-        shadow_color: RGB shadow color
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    x, y = center
-
-    # Draw shadow
-    shadow_center = (x + shadow_offset[0], y + shadow_offset[1])
-    shadow_bbox = [
-        shadow_center[0] - radius,
-        shadow_center[1] - radius,
-        shadow_center[0] + radius,
-        shadow_center[1] + radius
-    ]
-    draw.ellipse(shadow_bbox, fill=shadow_color)
-
-    # Draw main circle
-    bbox = [x - radius, y - radius, x + radius, y + radius]
-    draw.ellipse(bbox, fill=fill_color)
-
-    return frame
-
-
-def draw_rounded_rectangle(frame: Image.Image, top_left: tuple[int, int],
-                          bottom_right: 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 rectangle with rounded corners.
-
-    Args:
-        frame: PIL Image to draw on
-        top_left: (x, y) top-left corner
-        bottom_right: (x, y) bottom-right corner
-        radius: Corner radius
-        fill_color: RGB fill color (None for no fill)
-        outline_color: RGB outline color (None for no outline)
-        outline_width: Outline width
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    x1, y1 = top_left
-    x2, y2 = bottom_right
-
-    # Draw rounded rectangle using PIL's built-in method
-    draw.rounded_rectangle([x1, y1, x2, y2], radius=radius,
-                          fill=fill_color, outline=outline_color, width=outline_width)
-
-    return frame
-
-
-def add_vignette(frame: Image.Image, strength: float = 0.5) -> Image.Image:
-    """
-    Add a vignette effect (darkened edges) to frame.
-
-    Args:
-        frame: PIL Image
-        strength: Vignette strength (0.0-1.0)
-
-    Returns:
-        Frame with vignette
-    """
-    width, height = frame.size
-
-    # Create radial gradient mask
-    center_x, center_y = width // 2, height // 2
-    max_dist = ((width / 2) ** 2 + (height / 2) ** 2) ** 0.5
-
-    # Create overlay
-    overlay = Image.new('RGB', (width, height), (0, 0, 0))
-    pixels = overlay.load()
-
-    for y in range(height):
-        for x in range(width):
-            # Calculate distance from center
-            dx = x - center_x
-            dy = y - center_y
-            dist = (dx ** 2 + dy ** 2) ** 0.5
-
-            # Calculate vignette value
-            vignette = min(1, (dist / max_dist) * strength)
-            value = int(255 * (1 - vignette))
-            pixels[x, y] = (value, value, value)
-
-    # Blend with original using multiply
-    frame_array = np.array(frame, dtype=np.float32) / 255
-    overlay_array = np.array(overlay, dtype=np.float32) / 255
-
-    result = frame_array * overlay_array
-    result = (result * 255).astype(np.uint8)
-
-    return Image.fromarray(result)
-
-
-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