Initial commit: Piglet - Animated figlet wrapper

Add complete Rust implementation with:
- 20+ motion effects (fade, slide, scale, typewriter, wave, bounce, etc.)
- 18+ easing functions (linear, quad, cubic, elastic, back, bounce)
- Color support (CSS4 colors, hex codes, gradients)
- Figlet integration with custom fonts and options
- Cross-platform support (Linux, macOS, Windows)
- Comprehensive CI/CD workflows
- Full test suite with integration tests
- Documentation (README.md, CLAUDE.md)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/utils/ascii.rs

@@ -0,0 +1,131 @@
+use crate::parser::color::Color;
+
+#[derive(Debug, Clone)]
+pub struct AsciiArt {
+    lines: Vec<String>,
+    width: usize,
+    height: usize,
+}
+
+impl AsciiArt {
+    pub fn new(text: String) -> Self {
+        let lines: Vec<String> = text.lines().map(|s| s.to_string()).collect();
+        let width = lines.iter().map(|l| l.len()).max().unwrap_or(0);
+        let height = lines.len();
+        
+        Self {
+            lines,
+            width,
+            height,
+        }
+    }
+    
+    pub fn get_lines(&self) -> &[String] {
+        &self.lines
+    }
+    
+    pub fn width(&self) -> usize {
+        self.width
+    }
+    
+    pub fn height(&self) -> usize {
+        self.height
+    }
+    
+    pub fn to_string(&self) -> String {
+        self.lines.join("\n")
+    }
+    
+    /// Get character at position
+    pub fn char_at(&self, x: usize, y: usize) -> Option<char> {
+        self.lines.get(y)?.chars().nth(x)
+    }
+    
+    /// Count non-whitespace characters
+    pub fn char_count(&self) -> usize {
+        self.lines.iter()
+            .flat_map(|line| line.chars())
+            .filter(|c| !c.is_whitespace())
+            .count()
+    }
+    
+    /// Get all character positions
+    pub fn char_positions(&self) -> Vec<(usize, usize, char)> {
+        let mut positions = Vec::new();
+        
+        for (y, line) in self.lines.iter().enumerate() {
+            for (x, ch) in line.chars().enumerate() {
+                if !ch.is_whitespace() {
+                    positions.push((x, y, ch));
+                }
+            }
+        }
+        
+        positions
+    }
+    
+    /// Apply fade effect (0.0 = invisible, 1.0 = visible)
+    pub fn apply_fade(&self, opacity: f64) -> String {
+        if opacity >= 1.0 {
+            return self.to_string();
+        }
+        
+        if opacity <= 0.0 {
+            return " ".repeat(self.width).repeat(self.height);
+        }
+        
+        // For ASCII, we can simulate fade by replacing chars with lighter ones
+        let fade_chars = [' ', '.', '·', '-', '~', '=', '+', '*', '#', '@'];
+        let index = (opacity * (fade_chars.len() - 1) as f64) as usize;
+        let fade_char = fade_chars[index];
+        
+        self.lines.iter()
+            .map(|line| {
+                line.chars()
+                    .map(|ch| {
+                        if ch.is_whitespace() {
+                            ch
+                        } else {
+                            fade_char
+                        }
+                    })
+                    .collect::<String>()
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+    
+    /// Scale the ASCII art
+    pub fn scale(&self, factor: f64) -> Self {
+        if factor <= 0.0 {
+            return Self::new(String::new());
+        }
+        
+        if (factor - 1.0).abs() < 0.01 {
+            return self.clone();
+        }
+        
+        // Simple scaling by character repetition
+        let lines = if factor > 1.0 {
+            self.lines.iter()
+                .flat_map(|line| {
+                    let scaled_line: String = line.chars()
+                        .flat_map(|ch| std::iter::repeat(ch).take(factor as usize))
+                        .collect();
+                    std::iter::repeat(scaled_line).take(factor as usize)
+                })
+                .collect()
+        } else {
+            self.lines.iter()
+                .step_by((1.0 / factor) as usize)
+                .map(|line| {
+                    line.chars()
+                        .step_by((1.0 / factor) as usize)
+                        .collect()
+                })
+                .collect()
+        };
+        
+        Self::new(lines.join("\n"))
+    }
+}