anymous 1.2.7 → 1.3.0

package/skills/slack-gif-creator/core/gif_builder.py

@@ -0,0 +1,269 @@
+#!/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
+import numpy as np
+from PIL import Image
+
+
+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.9995) -> int:
+        """
+        Remove duplicate or near-duplicate consecutive frames.
+
+        Args:
+            threshold: Similarity threshold (0.0-1.0). Higher = more strict (0.9995 = nearly identical).
+                      Use 0.9995+ to preserve subtle animations, 0.98 for aggressive removal.
+
+        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.9995+) means only remove nearly 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 = False,
+    ) -> 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 emoji size (128x128, fewer colors)
+            remove_duplicates: If True, remove duplicate consecutive frames (opt-in)
+
+        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)
+
+        # Remove duplicate frames to reduce file size
+        if remove_duplicates:
+            removed = self.deduplicate_frames(threshold=0.9995)
+            if removed > 0:
+                print(
+                    f"  Removed {removed} nearly identical frames (preserved subtle animations)"
+                )
+
+        # 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}")
+
+        # Size info
+        if optimize_for_emoji:
+            print(f"  Optimized for emoji (128x128, reduced colors)")
+        if file_size_mb > 1.0:
+            print(f"\n  Note: Large file size ({file_size_kb:.1f} KB)")
+            print("  Consider: fewer frames, smaller dimensions, or fewer colors")
+
+        return info
+
+    def clear(self):
+        """Clear all frames (useful for creating multiple GIFs)."""
+        self.frames = []

package/skills/slack-gif-creator/core/validators.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Validators - Check if GIFs meet Slack's requirements.
+
+These validators help ensure your GIFs meet Slack's size and dimension constraints.
+"""
+
+from pathlib import Path
+
+
+def validate_gif(
+    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True
+) -> tuple[bool, dict]:
+    """
+    Validate GIF for Slack (dimensions, size, frame count).
+
+    Args:
+        gif_path: Path to GIF file
+        is_emoji: True for emoji (128x128 recommended), False for message GIF
+        verbose: Print validation details
+
+    Returns:
+        Tuple of (passes: bool, results: dict with all details)
+    """
+    from PIL import Image
+
+    gif_path = Path(gif_path)
+
+    if not gif_path.exists():
+        return False, {"error": f"File not found: {gif_path}"}
+
+    # Get file size
+    size_bytes = gif_path.stat().st_size
+    size_kb = size_bytes / 1024
+    size_mb = size_kb / 1024
+
+    # Get dimensions and frame info
+    try:
+        with Image.open(gif_path) as img:
+            width, height = img.size
+
+            # Count frames
+            frame_count = 0
+            try:
+                while True:
+                    img.seek(frame_count)
+                    frame_count += 1
+            except EOFError:
+                pass
+
+            # Get duration
+            try:
+                duration_ms = img.info.get("duration", 100)
+                total_duration = (duration_ms * frame_count) / 1000
+                fps = frame_count / total_duration if total_duration > 0 else 0
+            except:
+                total_duration = None
+                fps = None
+
+    except Exception as e:
+        return False, {"error": f"Failed to read GIF: {e}"}
+
+    # Validate dimensions
+    if is_emoji:
+        optimal = width == height == 128
+        acceptable = width == height and 64 <= width <= 128
+        dim_pass = acceptable
+    else:
+        aspect_ratio = (
+            max(width, height) / min(width, height)
+            if min(width, height) > 0
+            else float("inf")
+        )
+        dim_pass = aspect_ratio <= 2.0 and 320 <= min(width, height) <= 640
+
+    results = {
+        "file": str(gif_path),
+        "passes": dim_pass,
+        "width": width,
+        "height": height,
+        "size_kb": size_kb,
+        "size_mb": size_mb,
+        "frame_count": frame_count,
+        "duration_seconds": total_duration,
+        "fps": fps,
+        "is_emoji": is_emoji,
+        "optimal": optimal if is_emoji else None,
+    }
+
+    # Print if verbose
+    if verbose:
+        print(f"\nValidating {gif_path.name}:")
+        print(
+            f"  Dimensions: {width}x{height}"
+            + (
+                f" ({'optimal' if optimal else 'acceptable'})"
+                if is_emoji and acceptable
+                else ""
+            )
+        )
+        print(
+            f"  Size: {size_kb:.1f} KB"
+            + (f" ({size_mb:.2f} MB)" if size_mb >= 1.0 else "")
+        )
+        print(
+            f"  Frames: {frame_count}"
+            + (f" @ {fps:.1f} fps ({total_duration:.1f}s)" if fps else "")
+        )
+
+        if not dim_pass:
+            print(
+                f"  Note: {'Emoji should be 128x128' if is_emoji else 'Unusual dimensions for Slack'}"
+            )
+
+        if size_mb > 5.0:
+            print(f"  Note: Large file size - consider fewer frames/colors")
+
+    return dim_pass, results
+
+
+def is_slack_ready(
+    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True
+) -> bool:
+    """
+    Quick check if GIF is ready for Slack.
+
+    Args:
+        gif_path: Path to GIF file
+        is_emoji: True for emoji GIF, False for message GIF
+        verbose: Print feedback
+
+    Returns:
+        True if dimensions are acceptable
+    """
+    passes, _ = validate_gif(gif_path, is_emoji, verbose)
+    return passes

package/skills/slack-gif-creator/requirements.txt

@@ -0,0 +1,4 @@
+pillow>=10.0.0
+imageio>=2.31.0
+imageio-ffmpeg>=0.4.9
+numpy>=1.24.0

package/skills/staff-engineer-review/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: staff-engineer-review
+description: Performs deep code review of pull requests as a Staff+ level engineer. This skill should be used when reviewing PRs, evaluating implementation against plans, assessing architectural decisions, code quality, and providing actionable feedback.
+---
+
+# Staff Engineer Review
+
+## Overview
+
+Perform rigorous code review of pull requests by comparing the original plan (PR description) against actual implementation (code changes, diffs, structure). Evaluate alignment, architecture, code quality, correctness, performance, and test coverage to provide structured, actionable feedback.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Review a pull request and provide a structured evaluation
+- Evaluate whether implementation matches the stated plan
+- Assess architectural decisions in PRs
+- Provide detailed code review feedback
+- Check code quality, correctness, and performance implications
+- Evaluate test coverage adequacy
+
+## Review Workflow
+
+### 1. Gather Inputs
+
+Collect the following:
+- **PR Description** - The original plan and intent
+- **Code Changes** - Diffs, files modified, commits
+- **Additional Context** - Optional background, architecture docs, related PRs
+
+### 2. Plan vs Implementation Alignment
+
+Evaluate each item in the PR description against actual changes:
+
+| Check | Description |
+|-------|-------------|
+| Missing parts | Items planned but not implemented |
+| Extra changes | Changes implemented but not planned |
+| Partial implementations | Features started but not completed |
+
+Document each discrepancy with status: ✅ Done, ⚠️ Partial, ❌ Missing, ➕ Extra
+
+### 3. Architectural & Design Review
+
+Evaluate implementation against principles:
+
+**Assess:**
+- Separation of concerns
+- Coupling and cohesion
+- Consistency with existing codebase patterns
+- Scalability implications
+
+**Identify:**
+- Design flaws or anti-patterns
+- Overengineering or underengineering
+- Hidden complexity
+- Violations of SOLID/DRY principles
+
+### 4. Code Quality Review
+
+Check for:
+- Readability and clarity
+- Naming consistency with codebase conventions
+- Function and class responsibilities (single responsibility)
+- Code duplication
+- Cyclomatic and cognitive complexity
+- Edge case handling
+- Error handling completeness
+- Logging and observability
+
+### 5. Correctness & Risk Analysis
+
+Identify:
+- Logical errors or questionable assumptions
+- Potential bugs or edge case failures
+- Missing input validation
+- Race conditions or concurrency issues
+- Security vulnerabilities (injection, auth, data exposure)
+- API contract violations
+- Error handling gaps
+
+### 6. Performance Considerations
+
+Identify:
+- N+1 query patterns
+- Inefficient loops or operations
+- Memory inefficiencies
+- Unnecessary computations
+- Missing indexes or caching opportunities
+- Blocking operations in hot paths
+- Large data processing without streaming
+
+### 7. Test Coverage Evaluation
+
+Assess:
+- Unit tests for new functionality
+- Integration tests for component interactions
+- Edge case coverage
+- Happy path vs error path testing
+
+Identify missing tests and suggest specific test cases.
+
+## Output Format
+
+### 1. Summary
+
+Provide:
+- **Alignment Score**: 0-100% (plan vs implementation)
+- **Overall Quality**: Excellent / Good / Fair / Poor
+- **Risk Level**: Low / Medium / High
+
+### 2. Plan vs Reality
+
+| Item | Planned | Implemented | Status | Notes |
+|------|---------|-------------|--------|-------|
+| [Item 1] | Description from PR | What was actually done | ✅/⚠️/❌/➕ | Explanation |
+
+### 3. Critical Issues
+
+List only high-impact problems (if any):
+
+- **[Issue Title]**
+  - **Why it matters**: [Impact explanation]
+  - **Suggested fix**: [Concrete recommendation]
+
+### 4. Improvement Opportunities
+
+Group by category:
+
+**Architecture:**
+- [Issue] - [Recommendation]
+
+**Code Quality:**
+- [Issue] - [Recommendation]
+
+**Performance:**
+- [Issue] - [Recommendation]
+
+**Tests:**
+- [Issue] - [Recommendation]
+
+### 5. Suggested Additions to PR
+
+- Missing features or logic
+- Better approaches or patterns
+- Additional safeguards or validations
+
+### 6. Test Recommendations
+
+Specific test cases to add:
+
+- **[Test Case Name]**
+  - Input: [What to test]
+  - Expected: [Expected behavior]
+
+## Style Requirements
+
+- Be precise and structured
+- Avoid generic advice
+- Focus on actionable insights
+- Prioritize high-impact issues
+- Use bullet points and tables
+- Reference specific files and line numbers
+- State assumptions explicitly when information is unclear
+- Prefer practical engineering judgment over theoretical purity
+
+## Important Notes
+
+- Verify everything; do not assume correctness
+- Consider the context of the codebase and team conventions
+- Balance perfectionism with pragmatism
+- Focus review on what matters most for the PR's success