@amrhas82/agentic-kit 1.5.0 → 1.7.5

package/packages/droid/commands/slack-gif-creator/templates/spin.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-"""
-Spin Animation - Rotate objects continuously or with variation.
-
-Creates spinning, rotating, and wobbling effects.
-"""
-
-import sys
-from pathlib import Path
-import math
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced, draw_circle
-from core.easing import interpolate
-
-
-def create_spin_animation(
-    object_type: str = 'emoji',
-    object_data: dict | None = None,
-    num_frames: int = 30,
-    rotation_type: str = 'clockwise',  # 'clockwise', 'counterclockwise', 'wobble', 'pendulum'
-    full_rotations: float = 1.0,
-    easing: str = 'linear',
-    center_pos: tuple[int, int] = (240, 240),
-    frame_width: int = 480,
-    frame_height: int = 480,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Create spinning/rotating animation.
-
-    Args:
-        object_type: 'emoji', 'image', 'text'
-        object_data: Object configuration
-        num_frames: Number of frames
-        rotation_type: Type of rotation
-        full_rotations: Number of complete 360° rotations
-        easing: Easing function for rotation speed
-        center_pos: Center position for rotation
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    frames = []
-
-    # Default object data
-    if object_data is None:
-        if object_type == 'emoji':
-            object_data = {'emoji': '🔄', 'size': 100}
-
-    for i in range(num_frames):
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-        t = i / (num_frames - 1) if num_frames > 1 else 0
-
-        # Calculate rotation angle
-        if rotation_type == 'clockwise':
-            angle = interpolate(0, 360 * full_rotations, t, easing)
-        elif rotation_type == 'counterclockwise':
-            angle = interpolate(0, -360 * full_rotations, t, easing)
-        elif rotation_type == 'wobble':
-            # Back and forth rotation
-            angle = math.sin(t * full_rotations * 2 * math.pi) * 45
-        elif rotation_type == 'pendulum':
-            # Smooth pendulum swing
-            angle = math.sin(t * full_rotations * 2 * math.pi) * 90
-        else:
-            angle = interpolate(0, 360 * full_rotations, t, easing)
-
-        # Create object on transparent background to rotate
-        if object_type == 'emoji':
-            # For emoji, we need to create a larger canvas to avoid clipping during rotation
-            emoji_size = object_data['size']
-            canvas_size = int(emoji_size * 1.5)
-            emoji_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-            # Draw emoji in center of canvas
-            from core.frame_composer import draw_emoji_enhanced
-            draw_emoji_enhanced(
-                emoji_canvas,
-                emoji=object_data['emoji'],
-                position=(canvas_size // 2 - emoji_size // 2, canvas_size // 2 - emoji_size // 2),
-                size=emoji_size,
-                shadow=False
-            )
-
-            # Rotate the canvas
-            rotated = emoji_canvas.rotate(angle, resample=Image.BICUBIC, expand=False)
-
-            # Paste onto frame
-            paste_x = center_pos[0] - canvas_size // 2
-            paste_y = center_pos[1] - canvas_size // 2
-            frame.paste(rotated, (paste_x, paste_y), rotated)
-
-        elif object_type == 'text':
-            from core.typography import draw_text_with_outline
-            # Similar approach - create canvas, draw text, rotate
-            text = object_data.get('text', 'SPIN!')
-            font_size = object_data.get('font_size', 50)
-
-            canvas_size = max(frame_width, frame_height)
-            text_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-            # Draw text
-            text_canvas_rgb = text_canvas.convert('RGB')
-            text_canvas_rgb.paste(bg_color, (0, 0, canvas_size, canvas_size))
-            draw_text_with_outline(
-                text_canvas_rgb,
-                text,
-                position=(canvas_size // 2, canvas_size // 2),
-                font_size=font_size,
-                text_color=object_data.get('text_color', (0, 0, 0)),
-                outline_color=object_data.get('outline_color', (255, 255, 255)),
-                outline_width=3,
-                centered=True
-            )
-
-            # Convert back to RGBA for rotation
-            text_canvas = text_canvas_rgb.convert('RGBA')
-
-            # Make background transparent
-            data = text_canvas.getdata()
-            new_data = []
-            for item in data:
-                if item[:3] == bg_color:
-                    new_data.append((255, 255, 255, 0))
-                else:
-                    new_data.append(item)
-            text_canvas.putdata(new_data)
-
-            # Rotate
-            rotated = text_canvas.rotate(angle, resample=Image.BICUBIC, expand=False)
-
-            # Composite onto frame
-            frame_rgba = frame.convert('RGBA')
-            frame_rgba = Image.alpha_composite(frame_rgba, rotated)
-            frame = frame_rgba.convert('RGB')
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_loading_spinner(
-    num_frames: int = 20,
-    spinner_type: str = 'dots',  # 'dots', 'arc', 'emoji'
-    size: int = 100,
-    color: tuple[int, int, int] = (100, 150, 255),
-    frame_width: int = 128,
-    frame_height: int = 128,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Create a loading spinner animation.
-
-    Args:
-        num_frames: Number of frames
-        spinner_type: Type of spinner
-        size: Spinner size
-        color: Spinner color
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    from PIL import ImageDraw
-    frames = []
-    center = (frame_width // 2, frame_height // 2)
-
-    for i in range(num_frames):
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-        draw = ImageDraw.Draw(frame)
-
-        angle_offset = (i / num_frames) * 360
-
-        if spinner_type == 'dots':
-            # Circular dots
-            num_dots = 8
-            for j in range(num_dots):
-                angle = (j / num_dots * 360 + angle_offset) * math.pi / 180
-                x = center[0] + size * 0.4 * math.cos(angle)
-                y = center[1] + size * 0.4 * math.sin(angle)
-
-                # Fade based on position
-                alpha = 1.0 - (j / num_dots)
-                dot_color = tuple(int(c * alpha) for c in color)
-                dot_radius = int(size * 0.1)
-
-                draw.ellipse(
-                    [x - dot_radius, y - dot_radius, x + dot_radius, y + dot_radius],
-                    fill=dot_color
-                )
-
-        elif spinner_type == 'arc':
-            # Rotating arc
-            start_angle = angle_offset
-            end_angle = angle_offset + 270
-            arc_width = int(size * 0.15)
-
-            bbox = [
-                center[0] - size // 2,
-                center[1] - size // 2,
-                center[0] + size // 2,
-                center[1] + size // 2
-            ]
-            draw.arc(bbox, start_angle, end_angle, fill=color, width=arc_width)
-
-        elif spinner_type == 'emoji':
-            # Rotating emoji spinner
-            angle = angle_offset
-            emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-            draw_emoji_enhanced(
-                emoji_canvas,
-                emoji='⏳',
-                position=(center[0] - size // 2, center[1] - size // 2),
-                size=size,
-                shadow=False
-            )
-            rotated = emoji_canvas.rotate(angle, center=center, resample=Image.BICUBIC)
-            frame.paste(rotated, (0, 0), rotated)
-
-        frames.append(frame)
-
-    return frames
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating spin animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Clockwise spin
-    frames = create_spin_animation(
-        object_type='emoji',
-        object_data={'emoji': '🔄', 'size': 100},
-        num_frames=30,
-        rotation_type='clockwise',
-        full_rotations=2
-    )
-    builder.add_frames(frames)
-    builder.save('spin_clockwise.gif', num_colors=128)
-
-    # Example 2: Wobble
-    builder.clear()
-    frames = create_spin_animation(
-        object_type='emoji',
-        object_data={'emoji': '🎯', 'size': 100},
-        num_frames=30,
-        rotation_type='wobble',
-        full_rotations=3
-    )
-    builder.add_frames(frames)
-    builder.save('spin_wobble.gif', num_colors=128)
-
-    # Example 3: Loading spinner
-    builder = GIFBuilder(width=128, height=128, fps=15)
-    frames = create_loading_spinner(num_frames=20, spinner_type='dots')
-    builder.add_frames(frames)
-    builder.save('loading_spinner.gif', num_colors=64, optimize_for_emoji=True)
-
-    print("Created spin animations!")

package/packages/droid/commands/slack-gif-creator/templates/wiggle.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-"""
-Wiggle Animation - Smooth, organic wobbling and jiggling motions.
-
-Creates playful, elastic movements that are smoother than shake.
-"""
-
-import sys
-from pathlib import Path
-import math
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced
-from core.easing import interpolate
-
-
-def create_wiggle_animation(
-    object_type: str = 'emoji',
-    object_data: dict | None = None,
-    num_frames: int = 30,
-    wiggle_type: str = 'jello',  # 'jello', 'wave', 'bounce', 'sway'
-    intensity: float = 1.0,
-    cycles: float = 2.0,
-    center_pos: tuple[int, int] = (240, 240),
-    frame_width: int = 480,
-    frame_height: int = 480,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Create wiggle/wobble animation.
-
-    Args:
-        object_type: 'emoji', 'text'
-        object_data: Object configuration
-        num_frames: Number of frames
-        wiggle_type: Type of wiggle motion
-        intensity: Wiggle intensity multiplier
-        cycles: Number of wiggle cycles
-        center_pos: Center position
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    frames = []
-
-    # Default object data
-    if object_data is None:
-        if object_type == 'emoji':
-            object_data = {'emoji': '🎈', 'size': 100}
-
-    for i in range(num_frames):
-        t = i / (num_frames - 1) if num_frames > 1 else 0
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-
-        # Calculate wiggle transformations
-        offset_x = 0
-        offset_y = 0
-        rotation = 0
-        scale_x = 1.0
-        scale_y = 1.0
-
-        if wiggle_type == 'jello':
-            # Jello wobble - multiple frequencies
-            freq1 = cycles * 2 * math.pi
-            freq2 = cycles * 3 * math.pi
-            freq3 = cycles * 5 * math.pi
-
-            decay = 1.0 - t if cycles < 1.5 else 1.0  # Decay for single wiggles
-
-            offset_x = (
-                math.sin(freq1 * t) * 15 +
-                math.sin(freq2 * t) * 8 +
-                math.sin(freq3 * t) * 3
-            ) * intensity * decay
-
-            rotation = (
-                math.sin(freq1 * t) * 10 +
-                math.cos(freq2 * t) * 5
-            ) * intensity * decay
-
-            # Squash and stretch
-            scale_y = 1.0 + math.sin(freq1 * t) * 0.1 * intensity * decay
-            scale_x = 1.0 / scale_y  # Preserve volume
-
-        elif wiggle_type == 'wave':
-            # Wave motion
-            freq = cycles * 2 * math.pi
-            offset_y = math.sin(freq * t) * 20 * intensity
-            rotation = math.sin(freq * t + math.pi / 4) * 8 * intensity
-
-        elif wiggle_type == 'bounce':
-            # Bouncy wiggle
-            freq = cycles * 2 * math.pi
-            bounce = abs(math.sin(freq * t))
-
-            scale_y = 1.0 + bounce * 0.2 * intensity
-            scale_x = 1.0 - bounce * 0.1 * intensity
-            offset_y = -bounce * 10 * intensity
-
-        elif wiggle_type == 'sway':
-            # Gentle sway back and forth
-            freq = cycles * 2 * math.pi
-            offset_x = math.sin(freq * t) * 25 * intensity
-            rotation = math.sin(freq * t) * 12 * intensity
-
-            # Subtle scale change
-            scale = 1.0 + math.sin(freq * t) * 0.05 * intensity
-            scale_x = scale
-            scale_y = scale
-
-        elif wiggle_type == 'tail_wag':
-            # Like a wagging tail - base stays, tip moves
-            freq = cycles * 2 * math.pi
-            wag = math.sin(freq * t) * intensity
-
-            # Rotation focused at one end
-            rotation = wag * 20
-            offset_x = wag * 15
-
-        # Apply transformations
-        if object_type == 'emoji':
-            size = object_data['size']
-            size_x = int(size * scale_x)
-            size_y = int(size * scale_y)
-
-            # For non-uniform scaling or rotation, we need to use PIL transforms
-            if abs(scale_x - scale_y) > 0.01 or abs(rotation) > 0.1:
-                # Create emoji on transparent canvas
-                canvas_size = int(size * 2)
-                emoji_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-                # Draw emoji
-                draw_emoji_enhanced(
-                    emoji_canvas,
-                    emoji=object_data['emoji'],
-                    position=(canvas_size // 2 - size // 2, canvas_size // 2 - size // 2),
-                    size=size,
-                    shadow=False
-                )
-
-                # Scale
-                if abs(scale_x - scale_y) > 0.01:
-                    new_size = (int(canvas_size * scale_x), int(canvas_size * scale_y))
-                    emoji_canvas = emoji_canvas.resize(new_size, Image.LANCZOS)
-                    canvas_size_x, canvas_size_y = new_size
-                else:
-                    canvas_size_x = canvas_size_y = canvas_size
-
-                # Rotate
-                if abs(rotation) > 0.1:
-                    emoji_canvas = emoji_canvas.rotate(
-                        rotation,
-                        resample=Image.BICUBIC,
-                        expand=False
-                    )
-
-                # Position with offset
-                paste_x = int(center_pos[0] - canvas_size_x // 2 + offset_x)
-                paste_y = int(center_pos[1] - canvas_size_y // 2 + offset_y)
-
-                frame_rgba = frame.convert('RGBA')
-                frame_rgba.paste(emoji_canvas, (paste_x, paste_y), emoji_canvas)
-                frame = frame_rgba.convert('RGB')
-            else:
-                # Simple case - just offset
-                pos_x = int(center_pos[0] - size // 2 + offset_x)
-                pos_y = int(center_pos[1] - size // 2 + offset_y)
-                draw_emoji_enhanced(
-                    frame,
-                    emoji=object_data['emoji'],
-                    position=(pos_x, pos_y),
-                    size=size,
-                    shadow=object_data.get('shadow', True)
-                )
-
-        elif object_type == 'text':
-            from core.typography import draw_text_with_outline
-
-            # Create text on canvas for transformation
-            canvas_size = max(frame_width, frame_height)
-            text_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-            # Convert to RGB for drawing
-            text_canvas_rgb = text_canvas.convert('RGB')
-            text_canvas_rgb.paste(bg_color, (0, 0, canvas_size, canvas_size))
-
-            draw_text_with_outline(
-                text_canvas_rgb,
-                text=object_data.get('text', 'WIGGLE'),
-                position=(canvas_size // 2, canvas_size // 2),
-                font_size=object_data.get('font_size', 50),
-                text_color=object_data.get('text_color', (0, 0, 0)),
-                outline_color=object_data.get('outline_color', (255, 255, 255)),
-                outline_width=3,
-                centered=True
-            )
-
-            # Make transparent
-            text_canvas = text_canvas_rgb.convert('RGBA')
-            data = text_canvas.getdata()
-            new_data = []
-            for item in data:
-                if item[:3] == bg_color:
-                    new_data.append((255, 255, 255, 0))
-                else:
-                    new_data.append(item)
-            text_canvas.putdata(new_data)
-
-            # Apply rotation
-            if abs(rotation) > 0.1:
-                text_canvas = text_canvas.rotate(rotation, center=(canvas_size // 2, canvas_size // 2), resample=Image.BICUBIC)
-
-            # Crop to frame with offset
-            left = (canvas_size - frame_width) // 2 - int(offset_x)
-            top = (canvas_size - frame_height) // 2 - int(offset_y)
-            text_cropped = text_canvas.crop((left, top, left + frame_width, top + frame_height))
-
-            frame_rgba = frame.convert('RGBA')
-            frame = Image.alpha_composite(frame_rgba, text_cropped)
-            frame = frame.convert('RGB')
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_excited_wiggle(
-    emoji: str = '🎉',
-    num_frames: int = 20,
-    frame_size: int = 128
-) -> list[Image.Image]:
-    """
-    Create excited wiggle for emoji GIFs.
-
-    Args:
-        emoji: Emoji to wiggle
-        num_frames: Number of frames
-        frame_size: Frame size (square)
-
-    Returns:
-        List of frames
-    """
-    return create_wiggle_animation(
-        object_type='emoji',
-        object_data={'emoji': emoji, 'size': 80, 'shadow': False},
-        num_frames=num_frames,
-        wiggle_type='jello',
-        intensity=0.8,
-        cycles=2,
-        center_pos=(frame_size // 2, frame_size // 2),
-        frame_width=frame_size,
-        frame_height=frame_size,
-        bg_color=(255, 255, 255)
-    )
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating wiggle animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Jello wiggle
-    frames = create_wiggle_animation(
-        object_type='emoji',
-        object_data={'emoji': '🎈', 'size': 100},
-        num_frames=40,
-        wiggle_type='jello',
-        intensity=1.0,
-        cycles=2
-    )
-    builder.add_frames(frames)
-    builder.save('wiggle_jello.gif', num_colors=128)
-
-    # Example 2: Wave
-    builder.clear()
-    frames = create_wiggle_animation(
-        object_type='emoji',
-        object_data={'emoji': '🌊', 'size': 100},
-        num_frames=30,
-        wiggle_type='wave',
-        intensity=1.2,
-        cycles=3
-    )
-    builder.add_frames(frames)
-    builder.save('wiggle_wave.gif', num_colors=128)
-
-    # Example 3: Excited wiggle (emoji size)
-    builder = GIFBuilder(width=128, height=128, fps=15)
-    frames = create_excited_wiggle(emoji='🎉', num_frames=20)
-    builder.add_frames(frames)
-    builder.save('wiggle_excited.gif', num_colors=48, optimize_for_emoji=True)
-
-    print("Created wiggle animations!")