@caddis/cli 0.0.0 → 0.2.0

package/bundles/antigravity-plugin-extras/skills/slack-gif-creator/templates/zoom.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+Zoom Animation - Scale objects dramatically for emphasis.
+
+Creates zoom in, zoom out, and dramatic scaling effects.
+"""
+
+import sys
+from pathlib import Path
+import math
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from PIL import Image, ImageFilter
+from core.gif_builder import GIFBuilder
+from core.frame_composer import create_blank_frame, draw_emoji_enhanced
+from core.easing import interpolate
+
+
+def create_zoom_animation(
+    object_type: str = 'emoji',
+    object_data: dict | None = None,
+    num_frames: int = 30,
+    zoom_type: str = 'in',  # 'in', 'out', 'in_out', 'punch'
+    scale_range: tuple[float, float] = (0.1, 2.0),
+    easing: str = 'ease_out',
+    add_motion_blur: bool = False,
+    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 zoom animation.
+
+    Args:
+        object_type: 'emoji', 'text', 'image'
+        object_data: Object configuration
+        num_frames: Number of frames
+        zoom_type: Type of zoom effect
+        scale_range: (start_scale, end_scale) tuple
+        easing: Easing function
+        add_motion_blur: Add blur for speed effect
+        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}
+
+    base_size = object_data.get('size', 100) if object_type == 'emoji' else object_data.get('font_size', 60)
+    start_scale, end_scale = scale_range
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Calculate scale based on zoom type
+        if zoom_type == 'in':
+            scale = interpolate(start_scale, end_scale, t, easing)
+        elif zoom_type == 'out':
+            scale = interpolate(end_scale, start_scale, t, easing)
+        elif zoom_type == 'in_out':
+            if t < 0.5:
+                scale = interpolate(start_scale, end_scale, t * 2, easing)
+            else:
+                scale = interpolate(end_scale, start_scale, (t - 0.5) * 2, easing)
+        elif zoom_type == 'punch':
+            # Quick zoom in with overshoot then settle
+            if t < 0.3:
+                scale = interpolate(start_scale, end_scale * 1.2, t / 0.3, 'ease_out')
+            else:
+                scale = interpolate(end_scale * 1.2, end_scale, (t - 0.3) / 0.7, 'elastic_out')
+        else:
+            scale = interpolate(start_scale, end_scale, t, easing)
+
+        # Create frame
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+
+        if object_type == 'emoji':
+            current_size = int(base_size * scale)
+
+            # Clamp size to reasonable bounds
+            current_size = max(12, min(current_size, frame_width * 2))
+
+            # Create emoji on transparent background
+            canvas_size = max(frame_width, frame_height, current_size) * 2
+            emoji_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
+
+            draw_emoji_enhanced(
+                emoji_canvas,
+                emoji=object_data['emoji'],
+                position=(canvas_size // 2 - current_size // 2, canvas_size // 2 - current_size // 2),
+                size=current_size,
+                shadow=False
+            )
+
+            # Optional motion blur for fast zooms
+            if add_motion_blur and abs(scale - 1.0) > 0.5:
+                blur_amount = min(5, int(abs(scale - 1.0) * 3))
+                emoji_canvas = emoji_canvas.filter(ImageFilter.GaussianBlur(blur_amount))
+
+            # Crop to frame size centered
+            left = (canvas_size - frame_width) // 2
+            top = (canvas_size - frame_height) // 2
+            emoji_cropped = emoji_canvas.crop((left, top, left + frame_width, top + frame_height))
+
+            # Composite
+            frame_rgba = frame.convert('RGBA')
+            frame = Image.alpha_composite(frame_rgba, emoji_cropped)
+            frame = frame.convert('RGB')
+
+        elif object_type == 'text':
+            from core.typography import draw_text_with_outline
+
+            current_size = int(base_size * scale)
+            current_size = max(10, min(current_size, 500))
+
+            # Create oversized canvas for large text
+            canvas_size = max(frame_width, frame_height, current_size * 10)
+            text_canvas = Image.new('RGB', (canvas_size, canvas_size), bg_color)
+
+            draw_text_with_outline(
+                text_canvas,
+                text=object_data.get('text', 'ZOOM'),
+                position=(canvas_size // 2, canvas_size // 2),
+                font_size=current_size,
+                text_color=object_data.get('text_color', (0, 0, 0)),
+                outline_color=object_data.get('outline_color', (255, 255, 255)),
+                outline_width=max(2, int(current_size * 0.05)),
+                centered=True
+            )
+
+            # Crop to frame
+            left = (canvas_size - frame_width) // 2
+            top = (canvas_size - frame_height) // 2
+            frame = text_canvas.crop((left, top, left + frame_width, top + frame_height))
+
+        frames.append(frame)
+
+    return frames
+
+
+def create_explosion_zoom(
+    emoji: str = '💥',
+    num_frames: int = 20,
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Create dramatic explosion zoom effect.
+
+    Args:
+        emoji: Emoji to explode
+        num_frames: Number of frames
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Exponential zoom
+        scale = 0.1 * math.exp(t * 5)
+
+        # Add rotation for drama
+        angle = t * 360 * 2
+
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+
+        current_size = int(100 * scale)
+        current_size = max(12, min(current_size, frame_width * 3))
+
+        # Create emoji
+        canvas_size = max(frame_width, frame_height, current_size) * 2
+        emoji_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
+
+        draw_emoji_enhanced(
+            emoji_canvas,
+            emoji=emoji,
+            position=(canvas_size // 2 - current_size // 2, canvas_size // 2 - current_size // 2),
+            size=current_size,
+            shadow=False
+        )
+
+        # Rotate
+        emoji_canvas = emoji_canvas.rotate(angle, center=(canvas_size // 2, canvas_size // 2), resample=Image.BICUBIC)
+
+        # Add motion blur for later frames
+        if t > 0.5:
+            blur_amount = int((t - 0.5) * 10)
+            emoji_canvas = emoji_canvas.filter(ImageFilter.GaussianBlur(blur_amount))
+
+        # Crop and composite
+        left = (canvas_size - frame_width) // 2
+        top = (canvas_size - frame_height) // 2
+        emoji_cropped = emoji_canvas.crop((left, top, left + frame_width, top + frame_height))
+
+        frame_rgba = frame.convert('RGBA')
+        frame = Image.alpha_composite(frame_rgba, emoji_cropped)
+        frame = frame.convert('RGB')
+
+        frames.append(frame)
+
+    return frames
+
+
+def create_mind_blown_zoom(
+    emoji: str = '🤯',
+    num_frames: int = 30,
+    frame_width: int = 480,
+    frame_height: int = 480,
+    bg_color: tuple[int, int, int] = (255, 255, 255)
+) -> list[Image.Image]:
+    """
+    Create "mind blown" dramatic zoom with shake.
+
+    Args:
+        emoji: Emoji to use
+        num_frames: Number of frames
+        frame_width: Frame width
+        frame_height: Frame height
+        bg_color: Background color
+
+    Returns:
+        List of frames
+    """
+    frames = []
+
+    for i in range(num_frames):
+        t = i / (num_frames - 1) if num_frames > 1 else 0
+
+        # Zoom in then shake
+        if t < 0.5:
+            scale = interpolate(0.3, 1.2, t * 2, 'ease_out')
+            shake_x = 0
+            shake_y = 0
+        else:
+            scale = 1.2
+            # Shake intensifies
+            shake_intensity = (t - 0.5) * 40
+            shake_x = int(math.sin(t * 50) * shake_intensity)
+            shake_y = int(math.cos(t * 45) * shake_intensity)
+
+        frame = create_blank_frame(frame_width, frame_height, bg_color)
+
+        current_size = int(100 * scale)
+        center_x = frame_width // 2 + shake_x
+        center_y = frame_height // 2 + shake_y
+
+        emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
+        draw_emoji_enhanced(
+            emoji_canvas,
+            emoji=emoji,
+            position=(center_x - current_size // 2, center_y - current_size // 2),
+            size=current_size,
+            shadow=False
+        )
+
+        frame_rgba = frame.convert('RGBA')
+        frame = Image.alpha_composite(frame_rgba, emoji_canvas)
+        frame = frame.convert('RGB')
+
+        frames.append(frame)
+
+    return frames
+
+
+# Example usage
+if __name__ == '__main__':
+    print("Creating zoom animations...")
+
+    builder = GIFBuilder(width=480, height=480, fps=20)
+
+    # Example 1: Zoom in
+    frames = create_zoom_animation(
+        object_type='emoji',
+        object_data={'emoji': '🔍', 'size': 100},
+        num_frames=30,
+        zoom_type='in',
+        scale_range=(0.1, 1.5),
+        easing='ease_out'
+    )
+    builder.add_frames(frames)
+    builder.save('zoom_in.gif', num_colors=128)
+
+    # Example 2: Explosion zoom
+    builder.clear()
+    frames = create_explosion_zoom(emoji='💥', num_frames=20)
+    builder.add_frames(frames)
+    builder.save('zoom_explosion.gif', num_colors=128)
+
+    # Example 3: Mind blown
+    builder.clear()
+    frames = create_mind_blown_zoom(emoji='🤯', num_frames=30)
+    builder.add_frames(frames)
+    builder.save('zoom_mind_blown.gif', num_colors=128)
+
+    print("Created zoom animations!")

package/bundles/antigravity-plugin-extras/skills/slides/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: slides
+description: Create strategic HTML presentations with Chart.js, design tokens, responsive layouts, copywriting formulas, and contextual slide strategies.
+---
+
+# Slides
+
+Strategic HTML presentation design with data visualization.
+
+<args>$ARGUMENTS</args>
+
+## When to Use
+
+- Marketing presentations and pitch decks
+- Data-driven slides with Chart.js
+- Strategic slide design with layout patterns
+- Copywriting-optimized presentation content
+
+## Subcommands
+
+| Subcommand | Description | Reference |
+|------------|-------------|-----------|
+| `create` | Create strategic presentation slides | `references/create.md` |
+
+## References (Knowledge Base)
+
+| Topic | File |
+|-------|------|
+| Layout Patterns | `references/layout-patterns.md` |
+| HTML Template | `references/html-template.md` |
+| Copywriting Formulas | `references/copywriting-formulas.md` |
+| Slide Strategies | `references/slide-strategies.md` |
+
+## Routing
+
+1. Parse subcommand from `$ARGUMENTS` (first word)
+2. Load corresponding `references/{subcommand}.md`
+3. Execute with remaining arguments

package/bundles/antigravity-plugin-extras/skills/state-tracking/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: state-tracking
+context: fork
+description: "USE THIS SKILL when an agent needs to maintain a living record of task progress across multiple sessions or hand-offs. Covers append-only audit logs, CURRENT_STATE head-of-line pattern, relay hand-off protocol, and recovery from mid-session interruptions. Works in both generic and junai-pipeline modes."
+---
+
+# State Tracking Skill
+
+## When to Use
+
+Load this skill when you are:
+
+- Running a multi-session implementation where work spans more than one chat context
+- Handing off to another agent mid-plan and need to capture exactly where you stopped
+- Working on a long task where context compaction may occur
+- Recovering from an interrupted session and need to reconstruct current state
+
+---
+
+## The Two-Document Pattern
+
+State tracking uses two distinct documents with different write semantics:
+
+| Document | Write mode | Purpose |
+|----------|-----------|---------|
+| **Plan Tracker** (`.github/plans/tracker/<slug>-tracker.md`) | Overwrite each row | Per-phase completion record, linked to commits |
+| **CURRENT_STATE** (`.github/agent-docs/CURRENT_STATE.md`) | Overwrite head section | Single-view of right now: what phase, what's done, what's blocked |
+| **Session Log** (inline in CURRENT_STATE, append-only) | Append only | Chronological audit trail — never rewrite past entries |
+
+Never mix them: the tracker is the long-term ledger; CURRENT_STATE is the working note.
+
+---
+
+## CURRENT_STATE.md — Head-of-Line Pattern
+
+The CURRENT_STATE document has two sections:
+
+### Section 1: Current Status (overwrite on every update)
+
+Replace this section wholesale each time:
+
+```markdown
+## Current Status
+
+**Plan:** `.github/plans/<feature-slug>.md`
+**Tracker:** `.github/plans/tracker/<feature-slug>-tracker.md`
+**Last updated:** YYYY-MM-DDTHH:MM:SSZ
+**Active agent:** @[Agent] (model: [Model])
+**Current phase:** Phase N — [Name]
+**Phase status:** [Not started | In progress | Blocked | Complete]
+
+### What is done
+- Phase 1 ([Name]): complete — commit `abc1234`
+- Phase 2 ([Name]): complete — commit `def5678`
+
+### What is in progress
+- Phase 3 ([Name]): step 2 of 5 — [short note on current step]
+
+### What is blocked
+- [blocker description, or "nothing"]
+
+### Next action
+[One sentence: exactly what the next agent session should start with]
+```
+
+### Section 2: Session Log (append-only)
+
+Append one entry per session, never edit past entries:
+
+```markdown
+## Session Log
+
+### [YYYY-MM-DDTHH:MM:SSZ] — @[Agent] (model: [Model])
+**Phase covered:** Phase N [partial | complete]
+**Commits:** `abc1234` (phase(3): [Name] complete)
+**Stopped at:** [exact description of stopping point]
+**Handoff note:** [any context the next agent needs]
+---
+```
+
+---
+
+## Relay Hand-off Protocol
+
+When you are about to end a session mid-plan:
+
+1. **Complete the current atomic unit** — do not stop at a half-edited file. Reach the next clean commit point.
+2. **Update CURRENT_STATE.md:**
+   - Rewrite the "Current Status" section with the exact stopping point.
+   - Append a new entry to the Session Log.
+3. **Update the plan tracker** — mark your current phase's row with `In Progress` if incomplete, or `Complete` if you just finished it.
+4. **Commit both files** with the current phase commit or as a separate `chore(state): update CURRENT_STATE` commit.
+5. **State the hand-off note** in the session log and in your final reply — the next agent must be able to read CURRENT_STATE.md and know exactly where to start.
+
+---
+
+## Recovery Protocol
+
+When starting a session on a plan that has a CURRENT_STATE.md:
+
+1. Read `.github/agent-docs/CURRENT_STATE.md` — Current Status section first.
+2. Read the last entry in the Session Log to understand what the previous session did.
+3. Read the plan tracker row for the current phase.
+4. Confirm the stated commit exists: `git show <commit> --stat`.
+5. Start from **"Next action"** in the Current Status section.
+6. Do NOT re-run phases that are marked Complete in the tracker unless the user explicitly asks you to.
+
+---
+
+## Template: CURRENT_STATE.md
+
+The canonical template is at `.github/agent-docs/CURRENT_STATE.md`. Copy it for new plans or use it as the single shared state file (overwriting the Current Status section each session).
+
+---
+
+## Integration with Golden-Plan
+
+When running a golden-plan:
+- The plan tracker (`.github/plans/tracker/<slug>-tracker.md`) is the commitment ledger.
+- CURRENT_STATE.md is the working scratch-pad for the current session.
+- After completing a phase, update BOTH the tracker row AND the CURRENT_STATE current-status section.
+- When all tracker rows are `Complete`, follow the Plan Completion Protocol in golden-plan: move the plan to `plans/done/`, set `status: done`.
+
+---
+
+## Standing Rules
+
+1. **Never rewrite past Session Log entries** — the log is append-only. Corrections go in the next entry.
+2. **One CURRENT_STATE per active plan** — if running two plans in parallel, use two separate state files named `CURRENT_STATE-<slug>.md`.
+3. **CURRENT_STATE is not the tracker** — do not put commit hashes or gate results in CURRENT_STATE; they belong in the tracker. CURRENT_STATE is for human-readable context.
+4. **Commit state files** — CURRENT_STATE updates must be committed, not left as unstaged changes.