Claude Gif

#!/usr/bin/env bash
# Check dependency status for claude-gif (JSON output, no installs)
# Usage: bash scripts/check_deps.sh
set -euo pipefail

json_entry() {
    local name="$1" available="$2" version="${3:-}" install="${4:-}"
    if [ "$available" = "true" ]; then
        printf '{"name":"%s","available":true,"version":"%s"}' "$name" "$version"
    else
        printf '{"name":"%s","available":false,"install":"%s"}' "$name" "$install"
    fi
}

ENTRIES=()

# ffmpeg
if command -v ffmpeg &>/dev/null; then
    ver=$(ffmpeg -version 2>&1 | head -1 | awk '{print $3}')
    ENTRIES+=("$(json_entry "ffmpeg" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "ffmpeg" "false" "" "sudo apt install ffmpeg")")
fi

# gifsicle
if command -v gifsicle &>/dev/null; then
    ver=$(gifsicle --version 2>&1 | head -1 | grep -oP '[\d.]+' || echo "unknown")
    ENTRIES+=("$(json_entry "gifsicle" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "gifsicle" "false" "" "sudo apt install gifsicle")")
fi

# python3
if command -v python3 &>/dev/null; then
    ver=$(python3 --version 2>&1 | awk '{print $2}')
    ENTRIES+=("$(json_entry "python3" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "python3" "false" "" "pyenv install 3.12")")
fi

# Pillow
PYTHON_CMD="python3"
[ -f "$HOME/.video-skill/bin/python3" ] && PYTHON_CMD="$HOME/.video-skill/bin/python3"
if $PYTHON_CMD -c "from PIL import Image" 2>/dev/null; then
    ver=$($PYTHON_CMD -c "import PIL; print(PIL.__version__)" 2>/dev/null || echo "unknown")
    ENTRIES+=("$(json_entry "pillow" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "pillow" "false" "" "pip install Pillow")")
fi

# numpy
if $PYTHON_CMD -c "import numpy" 2>/dev/null; then
    ver=$($PYTHON_CMD -c "import numpy; print(numpy.__version__)" 2>/dev/null || echo "unknown")
    ENTRIES+=("$(json_entry "numpy" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "numpy" "false" "" "pip install numpy")")
fi

# node
if command -v node &>/dev/null; then
    ver=$(node --version 2>&1)
    ENTRIES+=("$(json_entry "node" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "node" "false" "" "nvm install --lts")")
fi

# imagemagick
if command -v convert &>/dev/null; then
    ver=$(convert --version 2>&1 | head -1 | grep -oP 'ImageMagick [\d.-]+' || echo "unknown")
    ENTRIES+=("$(json_entry "imagemagick" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "imagemagick" "false" "" "sudo apt install imagemagick")")
fi

# playwright
if command -v npx &>/dev/null && npx playwright --version &>/dev/null 2>&1; then
    ver=$(npx playwright --version 2>&1 || echo "unknown")
    ENTRIES+=("$(json_entry "playwright" "true" "$ver")")
else
    ENTRIES+=("$(json_entry "playwright" "false" "" "npx playwright install chromium")")
fi

# Output JSON
echo "["
for i in "${!ENTRIES[@]}"; do
    if [ "$i" -lt $((${#ENTRIES[@]} - 1)) ]; then
        echo "  ${ENTRIES[$i]},"
    else
        echo "  ${ENTRIES[$i]}"
    fi
done
echo "]"

#!/usr/bin/env bash
# Core GIF conversion — FFmpeg two-pass palette pipeline
# Usage: bash gif_convert.sh --input FILE [options]
#
# Options:
#   --input PATH       Input video/image file (required)
#   --output PATH      Output GIF path (default: input_basename.gif)
#   --fps N            Frame rate (default: 15)
#   --width N          Output width in px, height auto (default: 480)
#   --preset NAME      Quality preset: discord|slack|twitter|web|hq (overrides fps/width/colors/dither)
#   --start SS         Start time in seconds (default: 0)
#   --duration SS      Duration in seconds (default: full)
#   --dither ALGO      Dithering: floyd_steinberg|bayer:3|sierra2|sierra2_4a|none (default: floyd_steinberg)
#   --stats-mode MODE  Palette mode: full|diff|single (default: full)
#   --colors N         Max colors 2-256 (default: 256)
#   --loop N           Loop count: 0=infinite, N=fixed (default: 0)
#   --transparent      Enable transparency (single color key)
#   -y                 Overwrite output if exists
set -euo pipefail

# Defaults
INPUT=""
OUTPUT=""
FPS=15
WIDTH=480
PRESET=""
START=""
DURATION=""
DITHER="floyd_steinberg"
STATS_MODE="full"
COLORS=256
LOOP=0
OVERWRITE=""
TRANSPARENT=""

# Parse arguments
while [[ $# -gt 0 ]]; do
    case "$1" in
        --input)      INPUT="$2"; shift 2 ;;
        --output)     OUTPUT="$2"; shift 2 ;;
        --fps)        FPS="$2"; shift 2 ;;
        --width)      WIDTH="$2"; shift 2 ;;
        --preset)     PRESET="$2"; shift 2 ;;
        --start)      START="$2"; shift 2 ;;
        --duration)   DURATION="$2"; shift 2 ;;
        --dither)     DITHER="$2"; shift 2 ;;
        --stats-mode) STATS_MODE="$2"; shift 2 ;;
        --colors)     COLORS="$2"; shift 2 ;;
        --loop)       LOOP="$2"; shift 2 ;;
        --transparent) TRANSPARENT="1"; shift ;;
        -y)           OVERWRITE="-y"; shift ;;
        *)            echo "Unknown option: $1" >&2; exit 1 ;;
    esac
done

if [ -z "$INPUT" ]; then
    echo '{"error": "Missing --input argument"}' >&2
    exit 1
fi

if [ ! -f "$INPUT" ]; then
    echo "{\"error\": \"Input file not found: $INPUT\"}" >&2
    exit 1
fi

# Apply preset overrides
case "$PRESET" in
    discord)
        WIDTH=320; FPS=10; COLORS=128; DITHER="bayer:bayer_scale=3"; STATS_MODE="diff"
        ;;
    slack)
        WIDTH=400; FPS=12; COLORS=192; DITHER="floyd_steinberg"; STATS_MODE="full"
        ;;
    twitter)
        WIDTH=480; FPS=15; COLORS=256; DITHER="floyd_steinberg"; STATS_MODE="full"
        ;;
    web)
        WIDTH=480; FPS=15; COLORS=256; DITHER="floyd_steinberg"; STATS_MODE="full"
        ;;
    hq)
        WIDTH=640; FPS=20; COLORS=256; DITHER="sierra2"; STATS_MODE="diff"
        ;;
    "")
        ;; # No preset, use explicit values
    *)
        echo "{\"error\": \"Unknown preset: $PRESET. Use: discord|slack|twitter|web|hq\"}" >&2
        exit 1
        ;;
esac

# Default output path
if [ -z "$OUTPUT" ]; then
    BASENAME=$(basename "$INPUT")
    OUTPUT_DIR=$(dirname "$INPUT")
    OUTPUT="${OUTPUT_DIR}/${BASENAME%.*}.gif"
fi

# Ensure output directory exists
mkdir -p "$(dirname "$OUTPUT")"

# Temp palette file
PALETTE="/tmp/claude-gif/palette_$$.png"
mkdir -p /tmp/claude-gif
trap 'rm -f "$PALETTE"' EXIT INT TERM

# Build time selection flags
TIME_FLAGS=""
[ -n "$START" ] && TIME_FLAGS="-ss $START"
[ -n "$DURATION" ] && TIME_FLAGS="$TIME_FLAGS -t $DURATION"

# Build overwrite flag
OW_FLAG="${OVERWRITE:--n}"

# Build scale filter
SCALE_FILTER="scale=${WIDTH}:-1:flags=lanczos"

# Pass 1: Generate optimal palette
echo "Pass 1: Generating palette (${COLORS} colors, stats_mode=${STATS_MODE})..." >&2
ffmpeg -y $TIME_FLAGS -i "$INPUT" \
    -vf "fps=${FPS},${SCALE_FILTER},palettegen=max_colors=${COLORS}:stats_mode=${STATS_MODE}:reserve_transparent=${TRANSPARENT:-0}" \
    "$PALETTE" 2>/dev/null

# Pass 2: Apply palette with dithering
echo "Pass 2: Rendering GIF (dither=${DITHER}, loop=${LOOP})..." >&2
ffmpeg $OW_FLAG $TIME_FLAGS -i "$INPUT" -i "$PALETTE" \
    -lavfi "fps=${FPS},${SCALE_FILTER} [x]; [x][1:v] paletteuse=dither=${DITHER}:diff_mode=rectangle" \
    -loop "$LOOP" \
    "$OUTPUT" 2>/dev/null

# Get output stats
if [ -f "$OUTPUT" ]; then
    SIZE_BYTES=$(stat -c%s "$OUTPUT" 2>/dev/null || stat -f%z "$OUTPUT" 2>/dev/null)
    SIZE_KB=$((SIZE_BYTES / 1024))
    SIZE_MB=$(echo "scale=2; $SIZE_BYTES / 1048576" | bc 2>/dev/null || echo "N/A")

    # Get frame count and dimensions
    FRAME_INFO=$(ffprobe -v error -select_streams v:0 -show_entries stream=width,height,nb_frames,r_frame_rate -of json "$OUTPUT" 2>/dev/null || echo '{}')
    OUT_WIDTH=$(echo "$FRAME_INFO" | grep -oP '"width":\s*\K\d+' || echo "$WIDTH")
    OUT_HEIGHT=$(echo "$FRAME_INFO" | grep -oP '"height":\s*\K\d+' || echo "auto")

    cat <<EOF
{
  "success": true,
  "output": "$OUTPUT",
  "size_bytes": $SIZE_BYTES,
  "size_kb": $SIZE_KB,
  "size_mb": "$SIZE_MB",
  "width": $OUT_WIDTH,
  "height": $OUT_HEIGHT,
  "fps": $FPS,
  "colors": $COLORS,
  "dither": "$DITHER",
  "stats_mode": "$STATS_MODE",
  "preset": "${PRESET:-custom}",
  "loop": $LOOP
}
EOF
else
    echo '{"success": false, "error": "Output file was not created"}' >&2
    exit 1
fi

#!/usr/bin/env python3
"""Frame extraction, assembly, and SVG rendering for GIF creation.

Usage:
    # Assemble image sequence to GIF
    python3 gif_frames.py --input-dir DIR --output FILE [options]

    # Extract frames from GIF/video
    python3 gif_frames.py --extract FILE --output-dir DIR

    # Render animated SVG to frames (via Playwright)
    python3 gif_frames.py --svg FILE --output FILE [options]

Options:
    --input-dir DIR      Directory of PNG/JPG/WEBP frames
    --output PATH        Output GIF path
    --fps N              Frame rate (default: 15)
    --width N            Output width in px (default: 480)
    --preset NAME        Quality preset: discord|slack|twitter|web|hq
    --sort METHOD        Sort: name|modified (default: name)
    --reverse            Reverse frame order
    --extract PATH       Extract frames from GIF/video
    --output-dir DIR     Directory for extracted frames
    --svg PATH           Animated SVG file to render
    --svg-duration N     SVG animation duration in seconds (default: 3)
    --transparent        Preserve transparency (for SVG mode)
"""
import argparse
import glob
import json
import os
import re
import subprocess
import sys
import tempfile

PRESETS = {
    "discord":  {"width": 320, "fps": 10, "colors": 128, "dither": "bayer:bayer_scale=3"},
    "slack":    {"width": 400, "fps": 12, "colors": 192, "dither": "floyd_steinberg"},
    "twitter":  {"width": 480, "fps": 15, "colors": 256, "dither": "floyd_steinberg"},
    "web":      {"width": 480, "fps": 15, "colors": 256, "dither": "floyd_steinberg"},
    "hq":       {"width": 640, "fps": 20, "colors": 256, "dither": "sierra2"},
}


def natural_sort_key(s):
    """Sort strings with embedded numbers naturally."""
    return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', s)]


def find_frames(input_dir: str, sort: str = "name") -> list[str]:
    """Find image frames in directory."""
    extensions = ("*.png", "*.jpg", "*.jpeg", "*.webp", "*.bmp")
    frames = []
    for ext in extensions:
        frames.extend(glob.glob(os.path.join(input_dir, ext)))
    if sort == "modified":
        frames.sort(key=os.path.getmtime)
    else:
        frames.sort(key=natural_sort_key)
    return frames


def assemble_gif(frames: list[str], output: str, fps: int = 15, width: int = 480,
                  colors: int = 256, dither: str = "floyd_steinberg",
                  transparent: bool = False) -> dict:
    """Assemble image frames into optimized GIF using FFmpeg two-pass palette."""
    if not frames:
        return {"success": False, "error": "No frames found"}

    tmpdir = tempfile.mkdtemp(dir="/tmp/claude-gif", prefix="assemble_")
    palette = os.path.join(tmpdir, "palette.png")
    concat = os.path.join(tmpdir, "concat.txt")

    # Write concat file
    with open(concat, "w") as f:
        for frame in frames:
            f.write(f"file '{os.path.abspath(frame)}'\n")
            f.write(f"duration {1/fps}\n")

    reserve = "1" if transparent else "0"
    vf_scale = f"scale={width}:-1:flags=lanczos"

    try:
        # Pass 1: palette
        subprocess.run(
            ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat,
             "-vf", f"fps={fps},{vf_scale},palettegen=max_colors={colors}:stats_mode=full:reserve_transparent={reserve}",
             palette],
            capture_output=True, timeout=120, check=True
        )

        # Pass 2: apply palette
        alpha_thresh = ":alpha_threshold=128" if transparent else ""
        subprocess.run(
            ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat,
             "-i", palette,
             "-lavfi", f"fps={fps},{vf_scale} [x]; [x][1:v] paletteuse=dither={dither}:diff_mode=rectangle{alpha_thresh}",
             "-loop", "0", output],
            capture_output=True, timeout=120, check=True
        )

        size = os.path.getsize(output)
        return {
            "success": True,
            "output": output,
            "frames": len(frames),
            "fps": fps,
            "width": width,
            "colors": colors,
            "size_bytes": size,
            "size_kb": size // 1024,
            "transparent": transparent,
        }
    except subprocess.CalledProcessError as e:
        return {"success": False, "error": str(e), "stderr": e.stderr.decode()[-500:] if e.stderr else ""}
    finally:
        import shutil
        shutil.rmtree(tmpdir, ignore_errors=True)


def extract_frames(input_path: str, output_dir: str) -> dict:
    """Extract frames from GIF or video file."""
    os.makedirs(output_dir, exist_ok=True)
    pattern = os.path.join(output_dir, "frame_%04d.png")

    try:
        subprocess.run(
            ["ffmpeg", "-y", "-i", input_path, pattern],
            capture_output=True, timeout=120, check=True
        )
        frames = sorted(glob.glob(os.path.join(output_dir, "frame_*.png")))
        return {
            "success": True,
            "output_dir": output_dir,
            "frames": len(frames),
            "first": frames[0] if frames else None,
            "last": frames[-1] if frames else None,
        }
    except subprocess.CalledProcessError as e:
        return {"success": False, "error": str(e)}


def render_svg_to_frames(svg_path: str, output_dir: str, fps: int = 15,
                          duration: float = 3.0, width: int = 480,
                          height: int = 480) -> dict:
    """Render animated SVG to PNG frames using Playwright.

    This captures each frame of a SMIL/CSS animated SVG at the target FPS,
    producing transparent PNGs that can be assembled into a transparent GIF.
    """
    os.makedirs(output_dir, exist_ok=True)
    total_frames = int(fps * duration)

    # Generate a Node.js script that uses Playwright to capture frames
    capture_script = os.path.join(output_dir, "_capture.mjs")
    with open(capture_script, "w") as f:
        f.write(f"""
import {{ chromium }} from 'playwright';
import {{ readFileSync }} from 'fs';
import {{ resolve }} from 'path';

const svgPath = resolve('{os.path.abspath(svg_path)}');
const svgContent = readFileSync(svgPath, 'utf-8');
const outputDir = resolve('{os.path.abspath(output_dir)}');
const fps = {fps};
const duration = {duration};
const totalFrames = {total_frames};
const width = {width};
const height = {height};

const browser = await chromium.launch();
const page = await browser.newPage({{
    viewport: {{ width, height }},
    deviceScaleFactor: 1,
}});

// Load SVG in a minimal HTML page with transparent background
const html = `<!DOCTYPE html>
<html><head><style>
  html, body {{ margin: 0; padding: 0; background: transparent; overflow: hidden; }}
  svg {{ width: ${{width}}px; height: ${{height}}px; display: block; }}
</style></head>
<body>${{svgContent}}</body></html>`;

await page.setContent(html, {{ waitUntil: 'networkidle' }});

// Capture frames at target FPS intervals
const frameDelay = 1000 / fps;
for (let i = 0; i < totalFrames; i++) {{
    const padded = String(i).padStart(4, '0');
    await page.screenshot({{
        path: `${{outputDir}}/frame_${{padded}}.png`,
        omitBackground: true,
    }});
    // Advance time by waiting for next animation frame
    await page.waitForTimeout(frameDelay);
}}

await browser.close();
console.log(JSON.stringify({{ success: true, frames: totalFrames }}));
""")

    try:
        result = subprocess.run(
            ["node", capture_script],
            capture_output=True, text=True, timeout=120
        )
        if result.returncode != 0:
            return {
                "success": False,
                "error": "Playwright capture failed",
                "stderr": result.stderr[-500:] if result.stderr else "",
                "hint": "Run 'npx playwright install chromium' if not installed"
            }

        frames = sorted(glob.glob(os.path.join(output_dir, "frame_*.png")))
        return {
            "success": True,
            "output_dir": output_dir,
            "frames": len(frames),
            "fps": fps,
            "duration": duration,
            "transparent": True,
        }
    except subprocess.TimeoutExpired:
        return {"success": False, "error": "SVG render timed out (120s)"}
    finally:
        if os.path.exists(capture_script):
            os.unlink(capture_script)


def main():
    parser = argparse.ArgumentParser(description="GIF frame tools")
    parser.add_argument("--input-dir", help="Directory of image frames")
    parser.add_argument("--output", help="Output GIF path")
    parser.add_argument("--fps", type=int, default=15, help="Frame rate")
    parser.add_argument("--width", type=int, default=480, help="Output width")
    parser.add_argument("--height", type=int, default=480, help="Output height (SVG mode)")
    parser.add_argument("--preset", choices=list(PRESETS.keys()), help="Quality preset")
    parser.add_argument("--sort", choices=["name", "modified"], default="name")
    parser.add_argument("--reverse", action="store_true")
    parser.add_argument("--transparent", action="store_true")
    # Extract mode
    parser.add_argument("--extract", help="Extract frames from GIF/video")
    parser.add_argument("--output-dir", help="Output directory for extracted frames")
    # SVG mode
    parser.add_argument("--svg", help="Animated SVG file to render")
    parser.add_argument("--svg-duration", type=float, default=3.0, help="SVG animation duration")
    args = parser.parse_args()

    os.makedirs("/tmp/claude-gif", exist_ok=True)

    # Apply preset
    if args.preset:
        p = PRESETS[args.preset]
        args.width = p["width"]
        args.fps = p["fps"]
        colors = p["colors"]
        dither = p["dither"]
    else:
        colors = 256
        dither = "floyd_steinberg"

    # Mode: Extract frames
    if args.extract:
        out_dir = args.output_dir or "/tmp/claude-gif/extracted"
        result = extract_frames(args.extract, out_dir)
        print(json.dumps(result, indent=2))
        return

    # Mode: SVG render → GIF
    if args.svg:
        if not args.output:
            args.output = args.svg.replace(".svg", ".gif")
        render_dir = tempfile.mkdtemp(dir="/tmp/claude-gif", prefix="svg_")
        render_result = render_svg_to_frames(
            args.svg, render_dir, fps=args.fps,
            duration=args.svg_duration, width=args.width, height=args.height
        )
        if not render_result.get("success"):
            print(json.dumps(render_result, indent=2))
            sys.exit(1)

        frames = sorted(glob.glob(os.path.join(render_dir, "frame_*.png")))
        result = assemble_gif(frames, args.output, fps=args.fps, width=args.width,
                               colors=colors, dither=dither, transparent=True)
        print(json.dumps(result, indent=2))
        return

    # Mode: Assemble frames → GIF
    if args.input_dir:
        if not args.output:
            print(json.dumps({"error": "Missing --output"}))
            sys.exit(1)

        frames = find_frames(args.input_dir, args.sort)
        if args.reverse:
            frames.reverse()

        if not frames:
            print(json.dumps({"error": f"No image frames found in {args.input_dir}"}))
            sys.exit(1)

        result = assemble_gif(frames, args.output, fps=args.fps, width=args.width,
                               colors=colors, dither=dither, transparent=args.transparent)
        print(json.dumps(result, indent=2))
        return

    parser.print_help()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Perfect loop creation for GIFs — crossfade, ping-pong, and freeze-frame blending.

Usage:
    python3 gif_loop.py --input FILE [options]

Options:
    --input PATH         Input GIF file (required)
    --output PATH        Output path (default: input_loop.gif)
    --method METHOD      Loop method: crossfade|pingpong|freeze (default: crossfade)
    --frames N           Overlap frames for crossfade (default: 5)
    --blend-curve CURVE  Blending curve: sine|linear|ease (default: sine)
    --assess             Assess loop quality without modifying
"""
import argparse
import glob
import json
import math
import os
import subprocess
import sys
import tempfile

try:
    from PIL import Image
    HAS_PIL = True
except ImportError:
    HAS_PIL = False

try:
    import numpy as np
    HAS_NUMPY = True
except ImportError:
    HAS_NUMPY = False


def extract_frames(gif_path: str, output_dir: str) -> list[str]:
    """Extract GIF frames as PNG files using FFmpeg."""
    os.makedirs(output_dir, exist_ok=True)
    pattern = os.path.join(output_dir, "frame_%04d.png")
    subprocess.run(
        ["ffmpeg", "-y", "-i", gif_path, pattern],
        capture_output=True, timeout=60, check=True
    )
    frames = sorted(glob.glob(os.path.join(output_dir, "frame_*.png")))
    return frames


def get_frame_delay(gif_path: str) -> float:
    """Get average frame delay from GIF in seconds."""
    try:
        result = subprocess.run(
            ["ffprobe", "-v", "error", "-select_streams", "v:0",
             "-show_entries", "stream=r_frame_rate", "-of", "json", gif_path],
            capture_output=True, text=True, timeout=10
        )
        data = json.loads(result.stdout)
        fps_str = data.get("streams", [{}])[0].get("r_frame_rate", "15/1")
        num, den = map(int, fps_str.split("/"))
        return den / num if num > 0 else 1 / 15
    except Exception:
        return 1 / 15


def blend_alpha(t: float, curve: str = "sine") -> float:
    """Compute blend alpha for crossfade."""
    if curve == "sine":
        return (1 - math.cos(t * math.pi)) / 2
    elif curve == "ease":
        return t * t * (3 - 2 * t)
    else:  # linear
        return t


def crossfade_loop(frames: list[str], output_dir: str, overlap: int = 5,
                    curve: str = "sine") -> list[str]:
    """Create seamless loop by crossfading end into beginning."""
    if not HAS_PIL:
        raise RuntimeError("Pillow required for crossfade. Install: pip install Pillow")

    n = len(frames)
    if overlap >= n // 2:
        overlap = max(2, n // 4)

    images = [Image.open(f).convert("RGBA") for f in frames]

    # Blend the last `overlap` frames with the first `overlap` frames
    for i in range(overlap):
        t = i / (overlap - 1) if overlap > 1 else 0.5
        alpha = blend_alpha(t, curve)

        start_img = images[i]
        end_idx = n - overlap + i
        end_img = images[end_idx]

        blended = Image.blend(end_img, start_img, alpha)
        images[end_idx] = blended

    # Remove the first `overlap` frames (they're now blended into the end)
    result_images = images[overlap:]

    # Save
    os.makedirs(output_dir, exist_ok=True)
    result_paths = []
    for i, img in enumerate(result_images):
        path = os.path.join(output_dir, f"loop_{i:04d}.png")
        img.convert("RGB").save(path)
        result_paths.append(path)

    return result_paths


def pingpong_loop(frames: list[str], output_dir: str) -> list[str]:
    """Create ping-pong loop (forward then reverse, skip first/last to avoid pause)."""
    os.makedirs(output_dir, exist_ok=True)
    # Forward + reverse (excluding endpoints to avoid double-frame pause)
    all_frames = list(frames) + list(reversed(frames[1:-1]))
    result_paths = []
    for i, src in enumerate(all_frames):
        dst = os.path.join(output_dir, f"pong_{i:04d}.png")
        if os.path.abspath(src) != os.path.abspath(dst):
            subprocess.run(["cp", src, dst], check=True)
        result_paths.append(dst)
    return result_paths


def freeze_blend_loop(frames: list[str], output_dir: str) -> list[str]:
    """Blend first and last frames to create a subtle meeting point."""
    if not HAS_PIL:
        raise RuntimeError("Pillow required. Install: pip install Pillow")

    os.makedirs(output_dir, exist_ok=True)
    images = [Image.open(f).convert("RGB") for f in frames]

    # Average of first and last
    avg = Image.blend(images[0], images[-1], 0.5)
    images[0] = avg
    images[-1] = avg

    result_paths = []
    for i, img in enumerate(images):
        path = os.path.join(output_dir, f"freeze_{i:04d}.png")
        img.save(path)
        result_paths.append(path)
    return result_paths


def assess_loop_quality(gif_path: str) -> dict:
    """Measure how well a GIF loops by comparing first and last frames."""
    tmpdir = tempfile.mkdtemp(dir="/tmp/claude-gif", prefix="assess_")
    try:
        frames = extract_frames(gif_path, tmpdir)
        if len(frames) < 2:
            return {"error": "Need at least 2 frames", "frames": len(frames)}

        if HAS_PIL and HAS_NUMPY:
            first = np.array(Image.open(frames[0]).convert("RGB"), dtype=float)
            last = np.array(Image.open(frames[-1]).convert("RGB"), dtype=float)
            mae = float(np.mean(np.abs(first - last)))
        else:
            mae = -1  # Can't compute without numpy/PIL

        if mae < 0:
            rating = "unknown (install Pillow + numpy)"
        elif mae < 5:
            rating = "perfect"
        elif mae < 15:
            rating = "good"
        elif mae < 30:
            rating = "fair"
        else:
            rating = "poor"

        recommendation = ""
        if mae > 15:
            recommendation = "Use --method crossfade to blend the seam"
        elif mae > 5:
            recommendation = "Loop is decent; crossfade could improve it slightly"
        elif mae >= 0:
            recommendation = "Loop is already seamless"

        return {
            "frames": len(frames),
            "mae": round(mae, 2),
            "rating": rating,
            "recommendation": recommendation,
        }
    finally:
        import shutil
        shutil.rmtree(tmpdir, ignore_errors=True)


def assemble_gif(frame_paths: list[str], output_path: str, fps: int = 15) -> bool:
    """Assemble PNG frames into optimized GIF using FFmpeg two-pass palette."""
    if not frame_paths:
        return False

    tmpdir = os.path.dirname(frame_paths[0])
    palette = os.path.join(tmpdir, "palette.png")

    # Create concat file for non-sequential names
    concat_file = os.path.join(tmpdir, "concat.txt")
    with open(concat_file, "w") as f:
        for p in frame_paths:
            f.write(f"file '{os.path.abspath(p)}'\n")
            f.write(f"duration {1/fps}\n")

    try:
        # Pass 1: palette
        subprocess.run(
            ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat_file,
             "-vf", f"fps={fps},palettegen=max_colors=256:stats_mode=full",
             palette],
            capture_output=True, timeout=120, check=True
        )
        # Pass 2: apply
        subprocess.run(
            ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", concat_file,
             "-i", palette,
             "-lavfi", f"fps={fps} [x]; [x][1:v] paletteuse=dither=floyd_steinberg:diff_mode=rectangle",
             "-loop", "0", output_path],
            capture_output=True, timeout=120, check=True
        )
        return os.path.exists(output_path)
    except subprocess.CalledProcessError:
        return False


def main():
    parser = argparse.ArgumentParser(description="Create perfect GIF loops")
    parser.add_argument("--input", required=True, help="Input GIF file")
    parser.add_argument("--output", help="Output path")
    parser.add_argument("--method", choices=["crossfade", "pingpong", "freeze"],
                        default="crossfade", help="Loop method")
    parser.add_argument("--frames", type=int, default=5, help="Overlap frames for crossfade")
    parser.add_argument("--blend-curve", choices=["sine", "linear", "ease"],
                        default="sine", help="Blending curve")
    parser.add_argument("--assess", action="store_true", help="Assess loop quality only")
    args = parser.parse_args()

    if not os.path.exists(args.input):
        print(json.dumps({"error": f"Input not found: {args.input}"}))
        sys.exit(1)

    os.makedirs("/tmp/claude-gif", exist_ok=True)

    if args.assess:
        result = assess_loop_quality(args.input)
        print(json.dumps(result, indent=2))
        return

    output = args.output or args.input.replace(".gif", "_loop.gif")

    # Extract frames
    work_dir = tempfile.mkdtemp(dir="/tmp/claude-gif", prefix="loop_")
    extract_dir = os.path.join(work_dir, "extracted")
    loop_dir = os.path.join(work_dir, "looped")

    try:
        frames = extract_frames(args.input, extract_dir)
        if len(frames) < 4:
            print(json.dumps({"error": "Need at least 4 frames for loop creation"}))
            sys.exit(1)

        # Get original FPS
        delay = get_frame_delay(args.input)
        fps = max(1, round(1 / delay))

        # Apply loop method
        if args.method == "crossfade":
            looped = crossfade_loop(frames, loop_dir, args.frames, args.blend_curve)
        elif args.method == "pingpong":
            looped = pingpong_loop(frames, loop_dir)
        elif args.method == "freeze":
            looped = freeze_blend_loop(frames, loop_dir)
        else:
            looped = frames

        # Assemble
        if assemble_gif(looped, output, fps=fps):
            # Assess result
            quality = assess_loop_quality(output)
            result = {
                "success": True,
                "output": output,
                "method": args.method,
                "original_frames": len(frames),
                "output_frames": len(looped),
                "fps": fps,
                "loop_quality": quality,
                "size_kb": os.path.getsize(output) // 1024,
            }
            if args.method == "crossfade":
                result["overlap_frames"] = args.frames
                result["blend_curve"] = args.blend_curve
        else:
            result = {"success": False, "error": "Failed to assemble GIF"}

        print(json.dumps(result, indent=2))

    finally:
        import shutil
        shutil.rmtree(work_dir, ignore_errors=True)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Multi-strategy GIF optimization with platform auto-fit.

Usage:
    python3 gif_optimize.py --input FILE [options]

Options:
    --input PATH         Input GIF file (required)
    --output PATH        Output path (default: input_optimized.gif)
    --target-size SIZE   Target size: 256KB, 2MB, etc.
    --platform NAME      Platform preset: discord|slack|twitter|web|github|email
    --colors N           Max colors 2-256
    --lossy N            gifsicle lossy level 30-200 (default: 80)
    --dither ALGO        Dithering algorithm
    --analyze-only       Just report stats, don't optimize
"""
import argparse
import json
import os
import shutil
import subprocess
import sys
import tempfile

PLATFORM_LIMITS = {
    "discord": 256 * 1024,       # 256 KB
    "slack": 500 * 1024,         # 500 KB
    "email": 1024 * 1024,        # 1 MB
    "web": 2 * 1024 * 1024,      # 2 MB
    "github": 10 * 1024 * 1024,  # 10 MB
    "facebook": 8 * 1024 * 1024, # 8 MB
    "twitter": 15 * 1024 * 1024, # 15 MB
    "reddit": 20 * 1024 * 1024,  # 20 MB
}


def parse_size(size_str: str) -> int:
    """Parse human-readable size string to bytes."""
    size_str = size_str.strip().upper()
    multipliers = {"KB": 1024, "MB": 1024**2, "GB": 1024**3, "B": 1}
    for suffix, mult in sorted(multipliers.items(), key=lambda x: -len(x[0])):
        if size_str.endswith(suffix):
            return int(float(size_str[: -len(suffix)].strip()) * mult)
    return int(size_str)


def get_gif_info(path: str) -> dict:
    """Get GIF file info using ffprobe."""
    size = os.path.getsize(path)
    try:
        result = subprocess.run(
            ["ffprobe", "-v", "error", "-select_streams", "v:0",
             "-show_entries", "stream=width,height,nb_frames,r_frame_rate",
             "-show_entries", "format=duration",
             "-of", "json", path],
            capture_output=True, text=True, timeout=10
        )
        data = json.loads(result.stdout)
        stream = data.get("streams", [{}])[0]
        fmt = data.get("format", {})
        return {
            "path": path,
            "size_bytes": size,
            "size_kb": size // 1024,
            "width": int(stream.get("width", 0)),
            "height": int(stream.get("height", 0)),
            "frames": int(stream.get("nb_frames", 0)),
            "duration": float(fmt.get("duration", 0)),
        }
    except Exception:
        return {"path": path, "size_bytes": size, "size_kb": size // 1024}


def has_gifsicle() -> bool:
    return shutil.which("gifsicle") is not None


def optimize_gifsicle(input_path: str, output_path: str, lossy: int = 80, colors: int = 256) -> bool:
    """Optimize with gifsicle lossy compression."""
    cmd = ["gifsicle", "-O3", f"--lossy={lossy}"]
    if colors < 256:
        cmd.append(f"--colors={colors}")
    cmd.extend([input_path, "-o", output_path])
    try:
        subprocess.run(cmd, capture_output=True, timeout=60, check=True)
        return os.path.exists(output_path)
    except (subprocess.CalledProcessError, FileNotFoundError):
        return False


def optimize_repalette(input_path: str, output_path: str, colors: int = 256,
                       width: int = 0, fps: int = 0, dither: str = "floyd_steinberg") -> bool:
    """Re-palette GIF through FFmpeg two-pass pipeline."""
    vf_parts = []
    if fps > 0:
        vf_parts.append(f"fps={fps}")
    if width > 0:
        vf_parts.append(f"scale={width}:-1:flags=lanczos")

    palette_path = tempfile.mktemp(suffix=".png", dir="/tmp/claude-gif")
    try:
        # Pass 1: generate palette
        vf_palette = ",".join(vf_parts + [f"palettegen=max_colors={colors}:stats_mode=diff"])
        subprocess.run(
            ["ffmpeg", "-y", "-i", input_path, "-vf", vf_palette, palette_path],
            capture_output=True, timeout=120, check=True
        )
        # Pass 2: apply palette
        vf_use = ",".join(vf_parts) if vf_parts else ""
        if vf_use:
            lavfi = f"{vf_use} [x]; [x][1:v] paletteuse=dither={dither}:diff_mode=rectangle"
        else:
            lavfi = f"[0:v][1:v] paletteuse=dither={dither}:diff_mode=rectangle"
        subprocess.run(
            ["ffmpeg", "-y", "-i", input_path, "-i", palette_path, "-lavfi", lavfi,
             "-loop", "0", output_path],
            capture_output=True, timeout=120, check=True
        )
        return os.path.exists(output_path)
    except subprocess.CalledProcessError:
        return False
    finally:
        if os.path.exists(palette_path):
            os.unlink(palette_path)


def auto_fit(input_path: str, output_path: str, target_bytes: int) -> dict:
    """Iteratively optimize until under target size."""
    os.makedirs("/tmp/claude-gif", exist_ok=True)
    info = get_gif_info(input_path)
    current_path = input_path
    methods_applied = []

    # Strategy 1: gifsicle lossy
    if has_gifsicle():
        for lossy in [80, 120, 180]:
            tmp = tempfile.mktemp(suffix=".gif", dir="/tmp/claude-gif")
            if optimize_gifsicle(current_path, tmp, lossy=lossy):
                if os.path.getsize(tmp) < os.path.getsize(current_path):
                    if current_path != input_path:
                        os.unlink(current_path)
                    current_path = tmp
                    methods_applied.append(f"gifsicle --lossy={lossy}")
                    if os.path.getsize(current_path) <= target_bytes:
                        break
                else:
                    os.unlink(tmp)

    if os.path.getsize(current_path) <= target_bytes:
        if current_path != output_path:
            shutil.copy2(current_path, output_path)
            if current_path != input_path:
                os.unlink(current_path)
        return _result(info, output_path, methods_applied)

    # Strategy 2: reduce colors
    orig_width = info.get("width", 480)
    for colors in [192, 128, 64]:
        tmp = tempfile.mktemp(suffix=".gif", dir="/tmp/claude-gif")
        if optimize_repalette(current_path, tmp, colors=colors):
            if os.path.getsize(tmp) < os.path.getsize(current_path):
                if current_path != input_path:
                    os.unlink(current_path)
                current_path = tmp
                methods_applied.append(f"repalette colors={colors}")
                if os.path.getsize(current_path) <= target_bytes:
                    break
            else:
                os.unlink(tmp)

    if os.path.getsize(current_path) <= target_bytes:
        if current_path != output_path:
            shutil.copy2(current_path, output_path)
            if current_path != input_path:
                os.unlink(current_path)
        return _result(info, output_path, methods_applied)

    # Strategy 3: reduce dimensions (scale down 20% each step)
    width = orig_width
    for _ in range(5):
        width = int(width * 0.8)
        if width < 160:
            break
        tmp = tempfile.mktemp(suffix=".gif", dir="/tmp/claude-gif")
        if optimize_repalette(current_path, tmp, width=width, colors=128, dither="bayer:bayer_scale=3"):
            if current_path != input_path:
                os.unlink(current_path)
            current_path = tmp
            methods_applied.append(f"scale width={width}")
            if os.path.getsize(current_path) <= target_bytes:
                break

    if os.path.getsize(current_path) <= target_bytes:
        if current_path != output_path:
            shutil.copy2(current_path, output_path)
            if current_path != input_path:
                os.unlink(current_path)
        return _result(info, output_path, methods_applied)

    # Strategy 4: reduce frame rate
    for fps in [10, 8, 5]:
        tmp = tempfile.mktemp(suffix=".gif", dir="/tmp/claude-gif")
        if optimize_repalette(current_path, tmp, fps=fps, width=width, colors=128, dither="bayer:bayer_scale=3"):
            if current_path != input_path:
                os.unlink(current_path)
            current_path = tmp
            methods_applied.append(f"fps={fps}")
            if os.path.getsize(current_path) <= target_bytes:
                break

    # Final copy
    if current_path != output_path:
        shutil.copy2(current_path, output_path)
        if current_path != input_path:
            os.unlink(current_path)

    return _result(info, output_path, methods_applied)


def _result(original_info: dict, output_path: str, methods: list) -> dict:
    """Build result JSON."""
    opt_info = get_gif_info(output_path)
    orig_size = original_info["size_bytes"]
    opt_size = opt_info["size_bytes"]
    reduction = ((orig_size - opt_size) / orig_size * 100) if orig_size > 0 else 0
    return {
        "success": True,
        "input": original_info.get("path", ""),
        "output": output_path,
        "original_size_kb": orig_size // 1024,
        "optimized_size_kb": opt_size // 1024,
        "reduction_pct": round(reduction, 1),
        "methods_applied": methods,
        "output_width": opt_info.get("width", 0),
        "output_height": opt_info.get("height", 0),
        "output_frames": opt_info.get("frames", 0),
    }


def main():
    parser = argparse.ArgumentParser(description="Optimize GIF files")
    parser.add_argument("--input", required=True, help="Input GIF file")
    parser.add_argument("--output", help="Output path")
    parser.add_argument("--target-size", help="Target size (e.g., 256KB, 2MB)")
    parser.add_argument("--platform", choices=list(PLATFORM_LIMITS.keys()), help="Platform preset")
    parser.add_argument("--colors", type=int, default=256, help="Max colors")
    parser.add_argument("--lossy", type=int, default=80, help="gifsicle lossy level")
    parser.add_argument("--dither", default="floyd_steinberg", help="Dithering algorithm")
    parser.add_argument("--analyze-only", action="store_true", help="Just report stats")
    args = parser.parse_args()

    if not os.path.exists(args.input):
        print(json.dumps({"error": f"Input file not found: {args.input}"}))
        sys.exit(1)

    os.makedirs("/tmp/claude-gif", exist_ok=True)

    if args.analyze_only:
        info = get_gif_info(args.input)
        info["gifsicle_available"] = has_gifsicle()
        print(json.dumps(info, indent=2))
        return

    output = args.output or args.input.replace(".gif", "_optimized.gif")

    # Determine target
    if args.platform:
        target_bytes = PLATFORM_LIMITS[args.platform]
    elif args.target_size:
        target_bytes = parse_size(args.target_size)
    else:
        target_bytes = 2 * 1024 * 1024  # Default: 2MB (web)

    result = auto_fit(args.input, output, target_bytes)
    result["target_bytes"] = target_bytes
    result["target_platform"] = args.platform or "custom"
    result["under_target"] = os.path.getsize(output) <= target_bytes
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# Pre-flight safety check before any GIF write operation
# Usage: bash scripts/preflight.sh <input_file> <output_file>
# Output: JSON with pass/fail status and any warnings
set -euo pipefail

INPUT="${1:-}"
OUTPUT="${2:-}"

if [ -z "$INPUT" ] || [ -z "$OUTPUT" ]; then
    echo '{"pass":false,"error":"Usage: preflight.sh <input_file> <output_file>"}'
    exit 1
fi

WARNINGS=()
ERRORS=()

# Check input exists
if [ ! -f "$INPUT" ]; then
    ERRORS+=("Input file not found: $INPUT")
fi

# Check output != input (resolve symlinks and relative paths)
if [ -f "$INPUT" ]; then
    REAL_INPUT=$(realpath "$INPUT" 2>/dev/null || echo "$INPUT")
    REAL_OUTPUT=$(realpath -m "$OUTPUT" 2>/dev/null || echo "$OUTPUT")
    if [ "$REAL_INPUT" = "$REAL_OUTPUT" ]; then
        ERRORS+=("Output path equals input path — would destroy source file")
    fi
fi

# Check output doesn't already exist
if [ -f "$OUTPUT" ]; then
    WARNINGS+=("Output file already exists: $OUTPUT (use -y to overwrite)")
fi

# Check output directory exists
OUTPUT_DIR=$(dirname "$OUTPUT")
if [ ! -d "$OUTPUT_DIR" ]; then
    WARNINGS+=("Output directory does not exist: $OUTPUT_DIR (will be created)")
fi

# Check disk space (estimate 2x input size as safety margin)
if [ -f "$INPUT" ]; then
    INPUT_SIZE_KB=$(du -k "$INPUT" | cut -f1)
    NEEDED_KB=$((INPUT_SIZE_KB * 2))
    AVAIL_KB=$(df -k "$OUTPUT_DIR" 2>/dev/null | tail -1 | awk '{print $4}')
    if [ -n "$AVAIL_KB" ] && [ "$AVAIL_KB" -lt "$NEEDED_KB" ]; then
        WARNINGS+=("Low disk space: ${AVAIL_KB}KB available, estimated ${NEEDED_KB}KB needed")
    fi

    # GIF-specific: warn if input is very large
    INPUT_SIZE_MB=$((INPUT_SIZE_KB / 1024))
    if [ "$INPUT_SIZE_MB" -gt 100 ]; then
        WARNINGS+=("Large input (${INPUT_SIZE_MB}MB) — GIF output may be very large. Consider trimming or reducing resolution.")
    fi
fi

# Ensure temp directory exists
mkdir -p /tmp/claude-gif

# Build JSON output
PASS="true"
if [ ${#ERRORS[@]} -gt 0 ]; then
    PASS="false"
fi

ERROR_JSON="[]"
if [ ${#ERRORS[@]} -gt 0 ]; then
    ERROR_JSON=$(printf '%s\n' "${ERRORS[@]}" | jq -R . | jq -s .)
fi

WARN_JSON="[]"
if [ ${#WARNINGS[@]} -gt 0 ]; then
    WARN_JSON=$(printf '%s\n' "${WARNINGS[@]}" | jq -R . | jq -s .)
fi

cat <<EOF
{
  "pass": $PASS,
  "input": "$INPUT",
  "output": "$OUTPUT",
  "errors": $ERROR_JSON,
  "warnings": $WARN_JSON
}
EOF

[ "$PASS" = "true" ] && exit 0 || exit 1

#!/usr/bin/env bash
# Setup dependencies for claude-gif skill
# Usage: bash scripts/setup.sh [--check-only]
set -euo pipefail

CHECK_ONLY="${1:-}"
RESULTS=()
INSTALLED=0
FAILED=0

check_tool() {
    local name="$1" cmd="$2" install="$3"
    if command -v "$cmd" &>/dev/null; then
        local ver
        ver=$("$cmd" --version 2>&1 | head -1 || echo "unknown")
        RESULTS+=("{\"name\":\"$name\",\"available\":true,\"version\":\"$ver\"}")
    else
        RESULTS+=("{\"name\":\"$name\",\"available\":false,\"install\":\"$install\"}")
        if [ "$CHECK_ONLY" != "--check-only" ]; then
            echo "Installing $name..."
            if eval "$install" 2>/dev/null; then
                ((INSTALLED++))
            else
                ((FAILED++))
                echo "WARNING: Failed to install $name. Run manually: $install"
            fi
        fi
    fi
}

check_python_pkg() {
    local name="$1" import="$2"
    local python_cmd="python3"
    # Prefer video-skill venv if available
    [ -f "$HOME/.video-skill/bin/python3" ] && python_cmd="$HOME/.video-skill/bin/python3"

    if $python_cmd -c "import $import; print($import.__version__)" 2>/dev/null; then
        local ver
        ver=$($python_cmd -c "import $import; print($import.__version__)" 2>/dev/null)
        RESULTS+=("{\"name\":\"$name\",\"available\":true,\"version\":\"$ver\"}")
    else
        RESULTS+=("{\"name\":\"$name\",\"available\":false,\"install\":\"pip install $name\"}")
    fi
}

echo "=== claude-gif dependency check ==="

# Core tools
check_tool "ffmpeg" "ffmpeg" "sudo apt install -y ffmpeg"
check_tool "gifsicle" "gifsicle" "sudo apt install -y gifsicle"
check_tool "python3" "python3" "pyenv install 3.12"
check_tool "node" "node" "nvm install --lts"
check_tool "convert" "convert" "sudo apt install -y imagemagick"

# Python packages
check_python_pkg "Pillow" "PIL"
check_python_pkg "numpy" "numpy"

# Optional: Playwright for SVG rendering
if command -v npx &>/dev/null && npx playwright --version &>/dev/null 2>&1; then
    RESULTS+=("{\"name\":\"playwright\",\"available\":true}")
else
    RESULTS+=("{\"name\":\"playwright\",\"available\":false,\"install\":\"npx playwright install chromium\"}")
fi

# Create output directory
mkdir -p "$HOME/Documents/gif_output"
mkdir -p /tmp/claude-gif

# Build JSON output
echo ""
echo "{"
echo "  \"status\": \"complete\","
echo "  \"installed\": $INSTALLED,"
echo "  \"failed\": $FAILED,"
echo "  \"output_dir\": \"$HOME/Documents/gif_output\","
echo "  \"temp_dir\": \"/tmp/claude-gif\","
echo "  \"dependencies\": ["
for i in "${!RESULTS[@]}"; do
    if [ "$i" -lt $((${#RESULTS[@]} - 1)) ]; then
        echo "    ${RESULTS[$i]},"
    else
        echo "    ${RESULTS[$i]}"
    fi
done
echo "  ]"
echo "}"