@amrhas82/agentic-kit 1.7.0 → 1.7.6

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

@@ -1,246 +0,0 @@
-#!/usr/bin/env python3
-"""
-GIF Builder - Core module for assembling frames into GIFs optimized for Slack.
-
-This module provides the main interface for creating GIFs from programmatically
-generated frames, with automatic optimization for Slack's requirements.
-"""
-
-from pathlib import Path
-from typing import Optional
-import imageio.v3 as imageio
-from PIL import Image
-import numpy as np
-
-
-class GIFBuilder:
-    """Builder for creating optimized GIFs from frames."""
-
-    def __init__(self, width: int = 480, height: int = 480, fps: int = 15):
-        """
-        Initialize GIF builder.
-
-        Args:
-            width: Frame width in pixels
-            height: Frame height in pixels
-            fps: Frames per second
-        """
-        self.width = width
-        self.height = height
-        self.fps = fps
-        self.frames: list[np.ndarray] = []
-
-    def add_frame(self, frame: np.ndarray | Image.Image):
-        """
-        Add a frame to the GIF.
-
-        Args:
-            frame: Frame as numpy array or PIL Image (will be converted to RGB)
-        """
-        if isinstance(frame, Image.Image):
-            frame = np.array(frame.convert('RGB'))
-
-        # Ensure frame is correct size
-        if frame.shape[:2] != (self.height, self.width):
-            pil_frame = Image.fromarray(frame)
-            pil_frame = pil_frame.resize((self.width, self.height), Image.Resampling.LANCZOS)
-            frame = np.array(pil_frame)
-
-        self.frames.append(frame)
-
-    def add_frames(self, frames: list[np.ndarray | Image.Image]):
-        """Add multiple frames at once."""
-        for frame in frames:
-            self.add_frame(frame)
-
-    def optimize_colors(self, num_colors: int = 128, use_global_palette: bool = True) -> list[np.ndarray]:
-        """
-        Reduce colors in all frames using quantization.
-
-        Args:
-            num_colors: Target number of colors (8-256)
-            use_global_palette: Use a single palette for all frames (better compression)
-
-        Returns:
-            List of color-optimized frames
-        """
-        optimized = []
-
-        if use_global_palette and len(self.frames) > 1:
-            # Create a global palette from all frames
-            # Sample frames to build palette
-            sample_size = min(5, len(self.frames))
-            sample_indices = [int(i * len(self.frames) / sample_size) for i in range(sample_size)]
-            sample_frames = [self.frames[i] for i in sample_indices]
-
-            # Combine sample frames into a single image for palette generation
-            # Flatten each frame to get all pixels, then stack them
-            all_pixels = np.vstack([f.reshape(-1, 3) for f in sample_frames])  # (total_pixels, 3)
-
-            # Create a properly-shaped RGB image from the pixel data
-            # We'll make a roughly square image from all the pixels
-            total_pixels = len(all_pixels)
-            width = min(512, int(np.sqrt(total_pixels)))  # Reasonable width, max 512
-            height = (total_pixels + width - 1) // width  # Ceiling division
-
-            # Pad if necessary to fill the rectangle
-            pixels_needed = width * height
-            if pixels_needed > total_pixels:
-                padding = np.zeros((pixels_needed - total_pixels, 3), dtype=np.uint8)
-                all_pixels = np.vstack([all_pixels, padding])
-
-            # Reshape to proper RGB image format (H, W, 3)
-            img_array = all_pixels[:pixels_needed].reshape(height, width, 3).astype(np.uint8)
-            combined_img = Image.fromarray(img_array, mode='RGB')
-
-            # Generate global palette
-            global_palette = combined_img.quantize(colors=num_colors, method=2)
-
-            # Apply global palette to all frames
-            for frame in self.frames:
-                pil_frame = Image.fromarray(frame)
-                quantized = pil_frame.quantize(palette=global_palette, dither=1)
-                optimized.append(np.array(quantized.convert('RGB')))
-        else:
-            # Use per-frame quantization
-            for frame in self.frames:
-                pil_frame = Image.fromarray(frame)
-                quantized = pil_frame.quantize(colors=num_colors, method=2, dither=1)
-                optimized.append(np.array(quantized.convert('RGB')))
-
-        return optimized
-
-    def deduplicate_frames(self, threshold: float = 0.995) -> int:
-        """
-        Remove duplicate or near-duplicate consecutive frames.
-
-        Args:
-            threshold: Similarity threshold (0.0-1.0). Higher = more strict (0.995 = very similar).
-
-        Returns:
-            Number of frames removed
-        """
-        if len(self.frames) < 2:
-            return 0
-
-        deduplicated = [self.frames[0]]
-        removed_count = 0
-
-        for i in range(1, len(self.frames)):
-            # Compare with previous frame
-            prev_frame = np.array(deduplicated[-1], dtype=np.float32)
-            curr_frame = np.array(self.frames[i], dtype=np.float32)
-
-            # Calculate similarity (normalized)
-            diff = np.abs(prev_frame - curr_frame)
-            similarity = 1.0 - (np.mean(diff) / 255.0)
-
-            # Keep frame if sufficiently different
-            # High threshold (0.995) means only remove truly identical frames
-            if similarity < threshold:
-                deduplicated.append(self.frames[i])
-            else:
-                removed_count += 1
-
-        self.frames = deduplicated
-        return removed_count
-
-    def save(self, output_path: str | Path, num_colors: int = 128,
-             optimize_for_emoji: bool = False, remove_duplicates: bool = True) -> dict:
-        """
-        Save frames as optimized GIF for Slack.
-
-        Args:
-            output_path: Where to save the GIF
-            num_colors: Number of colors to use (fewer = smaller file)
-            optimize_for_emoji: If True, optimize for <64KB emoji size
-            remove_duplicates: Remove duplicate consecutive frames
-
-        Returns:
-            Dictionary with file info (path, size, dimensions, frame_count)
-        """
-        if not self.frames:
-            raise ValueError("No frames to save. Add frames with add_frame() first.")
-
-        output_path = Path(output_path)
-        original_frame_count = len(self.frames)
-
-        # Remove duplicate frames to reduce file size
-        if remove_duplicates:
-            removed = self.deduplicate_frames(threshold=0.98)
-            if removed > 0:
-                print(f"  Removed {removed} duplicate frames")
-
-        # Optimize for emoji if requested
-        if optimize_for_emoji:
-            if self.width > 128 or self.height > 128:
-                print(f"  Resizing from {self.width}x{self.height} to 128x128 for emoji")
-                self.width = 128
-                self.height = 128
-                # Resize all frames
-                resized_frames = []
-                for frame in self.frames:
-                    pil_frame = Image.fromarray(frame)
-                    pil_frame = pil_frame.resize((128, 128), Image.Resampling.LANCZOS)
-                    resized_frames.append(np.array(pil_frame))
-                self.frames = resized_frames
-            num_colors = min(num_colors, 48)  # More aggressive color limit for emoji
-
-            # More aggressive FPS reduction for emoji
-            if len(self.frames) > 12:
-                print(f"  Reducing frames from {len(self.frames)} to ~12 for emoji size")
-                # Keep every nth frame to get close to 12 frames
-                keep_every = max(1, len(self.frames) // 12)
-                self.frames = [self.frames[i] for i in range(0, len(self.frames), keep_every)]
-
-        # Optimize colors with global palette
-        optimized_frames = self.optimize_colors(num_colors, use_global_palette=True)
-
-        # Calculate frame duration in milliseconds
-        frame_duration = 1000 / self.fps
-
-        # Save GIF
-        imageio.imwrite(
-            output_path,
-            optimized_frames,
-            duration=frame_duration,
-            loop=0  # Infinite loop
-        )
-
-        # Get file info
-        file_size_kb = output_path.stat().st_size / 1024
-        file_size_mb = file_size_kb / 1024
-
-        info = {
-            'path': str(output_path),
-            'size_kb': file_size_kb,
-            'size_mb': file_size_mb,
-            'dimensions': f'{self.width}x{self.height}',
-            'frame_count': len(optimized_frames),
-            'fps': self.fps,
-            'duration_seconds': len(optimized_frames) / self.fps,
-            'colors': num_colors
-        }
-
-        # Print info
-        print(f"\n✓ GIF created successfully!")
-        print(f"  Path: {output_path}")
-        print(f"  Size: {file_size_kb:.1f} KB ({file_size_mb:.2f} MB)")
-        print(f"  Dimensions: {self.width}x{self.height}")
-        print(f"  Frames: {len(optimized_frames)} @ {self.fps} fps")
-        print(f"  Duration: {info['duration_seconds']:.1f}s")
-        print(f"  Colors: {num_colors}")
-
-        # Warnings
-        if optimize_for_emoji and file_size_kb > 64:
-            print(f"\n⚠️  WARNING: Emoji file size ({file_size_kb:.1f} KB) exceeds 64 KB limit")
-            print("   Try: fewer frames, fewer colors, or simpler design")
-        elif not optimize_for_emoji and file_size_kb > 2048:
-            print(f"\n⚠️  WARNING: File size ({file_size_kb:.1f} KB) is large for Slack")
-            print("   Try: fewer frames, smaller dimensions, or fewer colors")
-
-        return info
-
-    def clear(self):
-        """Clear all frames (useful for creating multiple GIFs)."""
-        self.frames = []

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

@@ -1,357 +0,0 @@
-#!/usr/bin/env python3
-"""
-Typography System - Professional text rendering with outlines, shadows, and effects.
-
-This module provides high-quality text rendering that looks crisp and professional
-in GIFs, with outlines for readability and effects for visual impact.
-"""
-
-from PIL import Image, ImageDraw, ImageFont
-from typing import Optional
-
-
-# Typography scale - proportional sizing system
-TYPOGRAPHY_SCALE = {
-    'h1': 60,      # Large headers
-    'h2': 48,      # Medium headers
-    'h3': 36,      # Small headers
-    'title': 50,   # Title text
-    'body': 28,    # Body text
-    'small': 20,   # Small text
-    'tiny': 16,    # Tiny text
-}
-
-
-def get_font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont:
-    """
-    Get a font with fallback support.
-
-    Args:
-        size: Font size in pixels
-        bold: Use bold variant if available
-
-    Returns:
-        ImageFont object
-    """
-    # Try multiple font paths for cross-platform support
-    font_paths = [
-        # macOS fonts
-        "/System/Library/Fonts/Helvetica.ttc",
-        "/System/Library/Fonts/SF-Pro.ttf",
-        "/Library/Fonts/Arial Bold.ttf" if bold else "/Library/Fonts/Arial.ttf",
-        # Linux fonts
-        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-        # Windows fonts
-        "C:\\Windows\\Fonts\\arialbd.ttf" if bold else "C:\\Windows\\Fonts\\arial.ttf",
-    ]
-
-    for font_path in font_paths:
-        try:
-            return ImageFont.truetype(font_path, size)
-        except:
-            continue
-
-    # Ultimate fallback
-    return ImageFont.load_default()
-
-
-def draw_text_with_outline(
-    frame: Image.Image,
-    text: str,
-    position: tuple[int, int],
-    font_size: int = 40,
-    text_color: tuple[int, int, int] = (255, 255, 255),
-    outline_color: tuple[int, int, int] = (0, 0, 0),
-    outline_width: int = 3,
-    centered: bool = False,
-    bold: bool = True
-) -> Image.Image:
-    """
-    Draw text with outline for maximum readability.
-
-    This is THE most important function for professional-looking text in GIFs.
-    The outline ensures text is readable on any background.
-
-    Args:
-        frame: PIL Image to draw on
-        text: Text to draw
-        position: (x, y) position
-        font_size: Font size in pixels
-        text_color: RGB color for text fill
-        outline_color: RGB color for outline
-        outline_width: Width of outline in pixels (2-4 recommended)
-        centered: If True, center text at position
-        bold: Use bold font variant
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    font = get_font(font_size, bold=bold)
-
-    # Calculate position for centering
-    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 outline by drawing text multiple times offset in all directions
-    x, y = position
-    for offset_x in range(-outline_width, outline_width + 1):
-        for offset_y in range(-outline_width, outline_width + 1):
-            if offset_x != 0 or offset_y != 0:
-                draw.text((x + offset_x, y + offset_y), text, fill=outline_color, font=font)
-
-    # Draw main text on top
-    draw.text(position, text, fill=text_color, font=font)
-
-    return frame
-
-
-def draw_text_with_shadow(
-    frame: Image.Image,
-    text: str,
-    position: tuple[int, int],
-    font_size: int = 40,
-    text_color: tuple[int, int, int] = (255, 255, 255),
-    shadow_color: tuple[int, int, int] = (0, 0, 0),
-    shadow_offset: tuple[int, int] = (3, 3),
-    centered: bool = False,
-    bold: bool = True
-) -> Image.Image:
-    """
-    Draw text with drop shadow for depth.
-
-    Args:
-        frame: PIL Image to draw on
-        text: Text to draw
-        position: (x, y) position
-        font_size: Font size in pixels
-        text_color: RGB color for text
-        shadow_color: RGB color for shadow
-        shadow_offset: (x, y) offset for shadow
-        centered: If True, center text at position
-        bold: Use bold font variant
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    font = get_font(font_size, bold=bold)
-
-    # Calculate position for centering
-    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 shadow
-    shadow_pos = (position[0] + shadow_offset[0], position[1] + shadow_offset[1])
-    draw.text(shadow_pos, text, fill=shadow_color, font=font)
-
-    # Draw main text
-    draw.text(position, text, fill=text_color, font=font)
-
-    return frame
-
-
-def draw_text_with_glow(
-    frame: Image.Image,
-    text: str,
-    position: tuple[int, int],
-    font_size: int = 40,
-    text_color: tuple[int, int, int] = (255, 255, 255),
-    glow_color: tuple[int, int, int] = (255, 200, 0),
-    glow_radius: int = 5,
-    centered: bool = False,
-    bold: bool = True
-) -> Image.Image:
-    """
-    Draw text with glow effect for emphasis.
-
-    Args:
-        frame: PIL Image to draw on
-        text: Text to draw
-        position: (x, y) position
-        font_size: Font size in pixels
-        text_color: RGB color for text
-        glow_color: RGB color for glow
-        glow_radius: Radius of glow effect
-        centered: If True, center text at position
-        bold: Use bold font variant
-
-    Returns:
-        Modified frame
-    """
-    draw = ImageDraw.Draw(frame)
-    font = get_font(font_size, bold=bold)
-
-    # Calculate position for centering
-    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 glow layers with decreasing opacity (simulated with same color at different offsets)
-    x, y = position
-    for radius in range(glow_radius, 0, -1):
-        for offset_x in range(-radius, radius + 1):
-            for offset_y in range(-radius, radius + 1):
-                if offset_x != 0 or offset_y != 0:
-                    draw.text((x + offset_x, y + offset_y), text, fill=glow_color, font=font)
-
-    # Draw main text
-    draw.text(position, text, fill=text_color, font=font)
-
-    return frame
-
-
-def draw_text_in_box(
-    frame: Image.Image,
-    text: str,
-    position: tuple[int, int],
-    font_size: int = 40,
-    text_color: tuple[int, int, int] = (255, 255, 255),
-    box_color: tuple[int, int, int] = (0, 0, 0),
-    box_alpha: float = 0.7,
-    padding: int = 10,
-    centered: bool = True,
-    bold: bool = True
-) -> Image.Image:
-    """
-    Draw text in a semi-transparent box for guaranteed readability.
-
-    Args:
-        frame: PIL Image to draw on
-        text: Text to draw
-        position: (x, y) position
-        font_size: Font size in pixels
-        text_color: RGB color for text
-        box_color: RGB color for background box
-        box_alpha: Opacity of box (0.0-1.0)
-        padding: Padding around text in pixels
-        centered: If True, center at position
-        bold: Use bold font variant
-
-    Returns:
-        Modified frame
-    """
-    # Create a separate layer for the box with alpha
-    overlay = Image.new('RGBA', frame.size, (0, 0, 0, 0))
-    draw_overlay = ImageDraw.Draw(overlay)
-    draw = ImageDraw.Draw(frame)
-
-    font = get_font(font_size, bold=bold)
-
-    # Get text dimensions
-    bbox = draw.textbbox((0, 0), text, font=font)
-    text_width = bbox[2] - bbox[0]
-    text_height = bbox[3] - bbox[1]
-
-    # Calculate box position
-    if centered:
-        box_x = position[0] - (text_width + padding * 2) // 2
-        box_y = position[1] - (text_height + padding * 2) // 2
-        text_x = position[0] - text_width // 2
-        text_y = position[1] - text_height // 2
-    else:
-        box_x = position[0] - padding
-        box_y = position[1] - padding
-        text_x = position[0]
-        text_y = position[1]
-
-    # Draw semi-transparent box
-    box_coords = [
-        box_x,
-        box_y,
-        box_x + text_width + padding * 2,
-        box_y + text_height + padding * 2
-    ]
-    alpha_value = int(255 * box_alpha)
-    draw_overlay.rectangle(box_coords, fill=(*box_color, alpha_value))
-
-    # Composite overlay onto frame
-    frame_rgba = frame.convert('RGBA')
-    frame_rgba = Image.alpha_composite(frame_rgba, overlay)
-    frame = frame_rgba.convert('RGB')
-
-    # Draw text on top
-    draw = ImageDraw.Draw(frame)
-    draw.text((text_x, text_y), text, fill=text_color, font=font)
-
-    return frame
-
-
-def get_text_size(text: str, font_size: int, bold: bool = True) -> tuple[int, int]:
-    """
-    Get the dimensions of text without drawing it.
-
-    Args:
-        text: Text to measure
-        font_size: Font size in pixels
-        bold: Use bold font variant
-
-    Returns:
-        (width, height) tuple
-    """
-    font = get_font(font_size, bold=bold)
-    # Create temporary image to measure
-    temp_img = Image.new('RGB', (1, 1))
-    draw = ImageDraw.Draw(temp_img)
-    bbox = draw.textbbox((0, 0), text, font=font)
-    width = bbox[2] - bbox[0]
-    height = bbox[3] - bbox[1]
-    return (width, height)
-
-
-def get_optimal_font_size(text: str, max_width: int, max_height: int,
-                          start_size: int = 60) -> int:
-    """
-    Find the largest font size that fits within given dimensions.
-
-    Args:
-        text: Text to size
-        max_width: Maximum width in pixels
-        max_height: Maximum height in pixels
-        start_size: Starting font size to try
-
-    Returns:
-        Optimal font size
-    """
-    font_size = start_size
-    while font_size > 10:
-        width, height = get_text_size(text, font_size)
-        if width <= max_width and height <= max_height:
-            return font_size
-        font_size -= 2
-    return 10  # Minimum font size
-
-
-def scale_font_for_frame(base_size: int, frame_width: int, frame_height: int) -> int:
-    """
-    Scale font size proportionally to frame dimensions.
-
-    Useful for maintaining relative text size across different GIF dimensions.
-
-    Args:
-        base_size: Base font size for 480x480 frame
-        frame_width: Actual frame width
-        frame_height: Actual frame height
-
-    Returns:
-        Scaled font size
-    """
-    # Use average dimension for scaling
-    avg_dimension = (frame_width + frame_height) / 2
-    base_dimension = 480  # Reference dimension
-    scale_factor = avg_dimension / base_dimension
-    return max(10, int(base_size * scale_factor))