@takuma-hirai/hirai-method 0.1.0

package/.claude/archive/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/.claude/archive/skills/twitter-algorithm-optimizer/SKILL.md

@@ -0,0 +1,327 @@
+---
+name: twitter-algorithm-optimizer
+description: Analyze and optimize tweets for maximum reach using Twitter's open-source algorithm insights. Rewrite and edit user tweets to improve engagement and visibility based on how the recommendation system ranks content.
+license: AGPL-3.0 (referencing Twitter's algorithm source)
+---
+
+# Twitter Algorithm Optimizer
+
+## When to Use This Skill
+
+Use this skill when you need to:
+- **Optimize tweet drafts** for maximum reach and engagement
+- **Understand why** a tweet might not perform well algorithmically
+- **Rewrite tweets** to align with Twitter's ranking mechanisms
+- **Improve content strategy** based on the actual ranking algorithms
+- **Debug underperforming content** and increase visibility
+- **Maximize engagement signals** that Twitter's algorithms track
+
+## What This Skill Does
+
+1. **Analyzes tweets** against Twitter's core recommendation algorithms
+2. **Identifies optimization opportunities** based on engagement signals
+3. **Rewrites and edits tweets** to improve algorithmic ranking
+4. **Explains the "why"** behind recommendations using algorithm insights
+5. **Applies Real-graph, SimClusters, and TwHIN principles** to content strategy
+6. **Provides engagement-boosting tactics** grounded in Twitter's actual systems
+
+## How It Works: Twitter's Algorithm Architecture
+
+Twitter's recommendation system uses multiple interconnected models:
+
+### Core Ranking Models
+
+**Real-graph**: Predicts interaction likelihood between users
+- Determines if your followers will engage with your content
+- Affects how widely Twitter shows your tweet to others
+- Key signal: Will followers like, reply, or retweet this?
+
+**SimClusters**: Community detection with sparse embeddings
+- Identifies communities of users with similar interests
+- Determines if your tweet resonates within specific communities
+- Key strategy: Make content that appeals to tight communities who will engage
+
+**TwHIN**: Knowledge graph embeddings for users and posts
+- Maps relationships between users and content topics
+- Helps Twitter understand if your tweet fits your follower interests
+- Key strategy: Stay in your niche or clearly signal topic shifts
+
+**Tweepcred**: User reputation/authority scoring
+- Higher-credibility users get more distribution
+- Your past engagement history affects current tweet reach
+- Key strategy: Build reputation through consistent engagement
+
+### Engagement Signals Tracked
+
+Twitter's **Unified User Actions** service tracks both explicit and implicit signals:
+
+**Explicit Signals** (high weight):
+- Likes (direct positive signal)
+- Replies (indicates valuable content worth discussing)
+- Retweets (strongest signal - users want to share it)
+- Quote tweets (engaged discussion)
+
+**Implicit Signals** (also weighted):
+- Profile visits (curiosity about the author)
+- Clicks/link clicks (content deemed useful enough to explore)
+- Time spent (users reading/considering your tweet)
+- Saves/bookmarks (plan to return later)
+
+**Negative Signals**:
+- Block/report (Twitter penalizes this heavily)
+- Mute/unfollow (person doesn't want your content)
+- Skip/scroll past quickly (low engagement)
+
+### The Feed Generation Process
+
+Your tweet reaches users through this pipeline:
+
+1. **Candidate Retrieval** - Multiple sources find candidate tweets:
+   - Search Index (relevant keyword matches)
+   - UTEG (timeline engagement graph - following relationships)
+   - Tweet-mixer (trending/viral content)
+
+2. **Ranking** - ML models rank candidates by predicted engagement:
+   - Will THIS user engage with THIS tweet?
+   - How quickly will engagement happen?
+   - Will it spread to non-followers?
+
+3. **Filtering** - Remove blocked content, apply preferences
+
+4. **Delivery** - Show ranked feed to user
+
+## Optimization Strategies Based on Algorithm Insights
+
+### 1. Maximize Real-graph (Follower Engagement)
+
+**Strategy**: Make content your followers WILL engage with
+
+- **Know your audience**: Reference topics they care about
+- **Ask questions**: Direct questions get more replies than statements
+- **Create controversy (safely)**: Debate attracts engagement (but avoid blocks/reports)
+- **Tag related creators**: Increases visibility through networks
+- **Post when followers are active**: Better early engagement means better ranking
+
+**Example Optimization**:
+- ❌ "I think climate policy is important"
+- ✅ "Hot take: Current climate policy ignores nuclear energy. Thoughts?" (triggers replies)
+
+### 2. Leverage SimClusters (Community Resonance)
+
+**Strategy**: Find and serve tight communities deeply interested in your topic
+
+- **Pick ONE clear topic**: Don't confuse the algorithm with mixed messages
+- **Use community language**: Reference shared memes, inside jokes, terminology
+- **Provide value to the niche**: Be genuinely useful to that specific community
+- **Encourage community-to-community sharing**: Quotes that spark discussion
+- **Build in your lane**: Consistency helps algorithm understand your topic
+
+**Example Optimization**:
+- ❌ "I use many programming languages"
+- ✅ "Rust's ownership system is the most underrated feature. Here's why..." (targets specific dev community)
+
+### 3. Improve TwHIN Mapping (Content-User Fit)
+
+**Strategy**: Make your content clearly relevant to your established identity
+
+- **Signal your expertise**: Lead with domain knowledge
+- **Consistency matters**: Stay in your lanes (or clearly announce a new direction)
+- **Use specific terminology**: Helps algorithm categorize you correctly
+- **Reference your past wins**: "Following up on my tweet about X..."
+- **Build topical authority**: Multiple tweets on same topic strengthen the connection
+
+**Example Optimization**:
+- ❌ "I like lots of things" (vague, confuses algorithm)
+- ✅ "My 3rd consecutive framework review as a full-stack engineer" (establishes authority)
+
+### 4. Boost Tweepcred (Authority/Credibility)
+
+**Strategy**: Build reputation through engagement consistency
+
+- **Reply to top creators**: Interaction with high-credibility accounts boosts visibility
+- **Quote interesting tweets**: Adds value and signals engagement
+- **Avoid engagement bait**: Doesn't build real credibility
+- **Be consistent**: Regular quality posting beats sporadic viral attempts
+- **Engage deeply**: Quality replies and discussions matter more than volume
+
+**Example Optimization**:
+- ❌ "RETWEET IF..." (engagement bait, damages credibility over time)
+- ✅ "Thoughtful critique of the approach in [linked tweet]" (builds authority)
+
+### 5. Maximize Engagement Signals
+
+**Explicit Signal Triggers**:
+
+**For Likes**:
+- Novel insights or memorable phrasing
+- Validation of audience beliefs
+- Useful/actionable information
+- Strong opinions with supporting evidence
+
+**For Replies**:
+- Ask a direct question
+- Create a debate
+- Request opinions
+- Share incomplete thoughts (invites completion)
+
+**For Retweets**:
+- Useful information people want to share
+- Representational value (tweet speaks for them)
+- Entertainment that entertains their followers
+- Information advantage (breaking news first)
+
+**For Bookmarks/Saves**:
+- Tutorials or how-tos
+- Data/statistics they'll reference later
+- Inspiration or motivation
+- Jokes/entertainment they'll want to see again
+
+**Example Optimization**:
+- ❌ "Check out this tool" (passive)
+- ✅ "This tool saved me 5 hours this week. Here's how to set it up..." (actionable, retweet-worthy)
+
+### 6. Prevent Negative Signals
+
+**Avoid**:
+- Inflammatory content likely to be reported
+- Targeted harassment (gets algorithmic penalty)
+- Misleading/false claims (damages credibility)
+- Off-brand pivots (confuses the algorithm)
+- Reply-guy syndrome (too many low-value replies)
+
+## How to Optimize Your Tweets
+
+### Step 1: Identify the Core Message
+- What's the single most important thing this tweet communicates?
+- Who should care about this?
+- What action/engagement do you want?
+
+### Step 2: Map to Algorithm Strategy
+- Which Real-graph follower segment will engage? (Followers who care about X)
+- Which SimCluster community? (Niche interested in Y)
+- How does this fit your TwHIN identity? (Your established expertise)
+- Does this boost or hurt Tweepcred?
+
+### Step 3: Optimize for Signals
+- Does it trigger replies? (Ask a question, create debate)
+- Is it retweet-worthy? (Usefulness, entertainment, representational value)
+- Will followers like it? (Novel, validating, actionable)
+- Could it go viral? (Community resonance + network effects)
+
+### Step 4: Check Against Negatives
+- Any blocks/reports risk?
+- Any confusion about your identity?
+- Any engagement bait that damages credibility?
+- Any inflammatory language that hurts Tweepcred?
+
+## Example Optimizations
+
+### Example 1: Developer Tweet
+
+**Original**:
+> "I fixed a bug today"
+
+**Algorithm Analysis**:
+- No clear audience - too generic
+- No engagement signals - statements don't trigger replies
+- No Real-graph trigger - followers won't engage strongly
+- No SimCluster resonance - could apply to any developer
+
+**Optimized**:
+> "Spent 2 hours debugging, turned out I was missing one semicolon. The best part? The linter didn't catch it.
+>
+> What's your most embarrassing bug? Drop it in replies 👇"
+
+**Why It Works**:
+- SimCluster trigger: Specific developer community
+- Real-graph trigger: Direct question invites replies
+- Tweepcred: Relatable vulnerability builds connection
+- Engagement: Likely replies (others share embarrassing bugs)
+
+### Example 2: Product Launch Tweet
+
+**Original**:
+> "We launched a new feature today. Check it out."
+
+**Algorithm Analysis**:
+- Passive voice - doesn't indicate impact
+- No specific benefit - followers don't know why to care
+- No community resonance - generic
+- Engagement bait risk if it feels like self-promotion
+
+**Optimized**:
+> "Spent 6 months on the one feature our users asked for most: export to PDF.
+>
+> 10x improvement in report generation time. Already live.
+>
+> What export format do you want next?"
+
+**Why It Works**:
+- Real-graph: Followers in your product space will engage
+- Specificity: "PDF export" + "10x improvement" triggers bookmarks (useful info)
+- Question: Ends with engagement trigger
+- Authority: You spent 6 months (shows credibility)
+- SimCluster: Product management/SaaS community resonates
+
+### Example 3: Opinion Tweet
+
+**Original**:
+> "I think remote work is better than office work"
+
+**Algorithm Analysis**:
+- Vague opinion - doesn't invite engagement
+- Could be debated either way - no clear position
+- No Real-graph hooks - followers unclear if they should care
+- Generic topic - dilutes your personal brand
+
+**Optimized**:
+> "Hot take: remote work works great for async tasks but kills creative collaboration.
+>
+> We're now hybrid: deep focus days remote, collab days in office.
+>
+> What's your team's balance? Genuinely curious what works."
+
+**Why It Works**:
+- Clear position: Not absolutes, nuanced stance
+- Debate trigger: "Hot take" signals discussion opportunity
+- Question: Direct engagement request
+- Real-graph: Followers in your industry will have opinions
+- SimCluster: CTOs, team leads, engineering managers will relate
+- Tweepcred: Nuanced thinking builds authority
+
+## Best Practices for Algorithm Optimization
+
+1. **Quality Over Virality**: Consistent engagement from your community beats occasional viral moments
+2. **Community First**: Deep resonance with 100 engaged followers beats shallow reach to 10,000
+3. **Authenticity Matters**: The algorithm rewards genuine engagement, not manipulation
+4. **Timing Helps**: Engage early when tweet is fresh (first hour critical)
+5. **Build Threads**: Threaded tweets often get more engagement than single tweets
+6. **Follow Up**: Reply to replies quickly - Twitter's algorithm favors active conversation
+7. **Avoid Spam**: Engagement pods and bots hurt long-term credibility
+8. **Track Your Performance**: Notice what YOUR audience engages with and iterate
+
+## Common Pitfalls to Avoid
+
+- **Generic statements**: Doesn't trigger algorithm (too vague)
+- **Pure engagement bait**: "Like if you agree" - hurts credibility long-term
+- **Unclear audience**: Who should care? If unclear, algorithm won't push it far
+- **Off-brand pivots**: Confuses algorithm about your identity
+- **Over-frequency**: Spamming hurts engagement rate metrics
+- **Toxicity**: Blocks/reports heavily penalize future reach
+- **No calls to action**: Passive tweets underperform
+
+## When to Ask for Algorithm Optimization
+
+Use this skill when:
+- You've drafted a tweet and want to maximize reach
+- A tweet underperformed and you want to understand why
+- You're launching important content and want algorithm advantage
+- You're building audience in a specific niche
+- You want to become known for something specific
+- You're debugging inconsistent engagement rates
+
+Use Claude without this skill for:
+- General writing and grammar fixes
+- Tone adjustments not related to algorithm
+- Off-Twitter content (LinkedIn, Medium, blogs, etc.)
+- Personal conversations and casual tweets