cokit-cli 1.0.8 → 1.2.0

package/templates/repo/.github/skills/ck-media-processing/references/troubleshooting.md

@@ -1,109 +0,0 @@
-# Media Processing Troubleshooting
-
-## FFmpeg Issues
-
-### Unknown Encoder Error
-```bash
-# Check available encoders
-ffmpeg -encoders | grep h264
-
-# Install codec libraries (Ubuntu/Debian)
-sudo apt-get install libx264-dev libx265-dev libvpx-dev
-```
-
-### Memory Errors
-```bash
-# Limit thread usage
-ffmpeg -threads 4 input.mp4 output.mp4
-
-# Process in segments for large files
-ffmpeg -i large.mp4 -ss 0 -t 600 segment1.mp4
-ffmpeg -i large.mp4 -ss 600 -t 600 segment2.mp4
-```
-
-### Slow Encoding
-```bash
-# Use faster preset (trades compression for speed)
-ffmpeg -i input.mp4 -c:v libx264 -preset ultrafast output.mp4
-
-# Use hardware acceleration
-ffmpeg -hwaccel cuda -i input.mp4 -c:v h264_nvenc output.mp4
-```
-
-## ImageMagick Issues
-
-### "Not Authorized" Error
-```bash
-# Edit policy file
-sudo nano /etc/ImageMagick-7/policy.xml
-
-# Change from:
-# <policy domain="coder" rights="none" pattern="PDF" />
-
-# To:
-# <policy domain="coder" rights="read|write" pattern="PDF" />
-```
-
-### Memory Limit Errors
-```bash
-# Increase memory limits
-magick -limit memory 2GB -limit map 4GB input.jpg output.jpg
-
-# Process in batches for large sets
-ls *.jpg | xargs -n 10 -P 4 mogrify -resize 800x
-```
-
-### Slow Batch Processing
-```bash
-# Use parallel processing with GNU Parallel
-ls *.jpg | parallel -j 4 magick {} -resize 800x resized-{}
-
-# Or use mogrify for in-place edits (faster)
-mogrify -resize 800x *.jpg
-```
-
-## RMBG Issues
-
-### Model Download Failures
-```bash
-# Check network connectivity
-curl https://unpkg.com/@rmbg/model-modnet/modnet-256.onnx
-
-# Use custom cache directory
-RMBG_CACHE_DIR=/tmp/rmbg-cache rmbg input.jpg
-
-# Clear cache and retry
-rm -rf /tmp/rmbg-cache
-rmbg input.jpg
-```
-
-### Out of Memory
-```bash
-# Use smaller model
-rmbg input.jpg -m u2netp -o output.png
-
-# Reduce resolution
-rmbg input.jpg -r 1024 -o output.png
-```
-
-### Slow Processing
-```bash
-# Use fastest model
-rmbg input.jpg -m u2netp -o output.png
-
-# Process smaller resolution
-rmbg input.jpg -r 1024 -o output.png
-```
-
-## Performance Tips
-
-1. **Use CRF for quality control** - Better than bitrate for video encoding
-2. **Copy streams when possible** - Avoid re-encoding with `-c copy`
-3. **Hardware acceleration** - GPU encoding 5-10x faster than CPU
-4. **Appropriate presets** - Balance speed vs compression (`fast`, `medium`, `slow`)
-5. **Batch with mogrify** - In-place image processing faster than individual commands
-6. **Strip metadata** - Reduce file size with `-strip` flag
-7. **Progressive JPEG** - Better web loading with `-interlace Plane`
-8. **Test on samples** - Verify settings before processing large batches
-9. **Parallel processing** - Use GNU Parallel for multiple files
-10. **Limit memory** - Prevent crashes on large batches with `-limit` flags

package/templates/repo/.github/skills/ck-media-processing/scripts/README.md

@@ -1,111 +0,0 @@
-# Media Processing Scripts
-
-Helper scripts for common media processing tasks.
-
-## Background Removal Scripts
-
-### remove-background.sh
-Remove background from a single image using RMBG CLI.
-
-```bash
-# Basic usage
-./remove-background.sh photo.jpg
-
-# With specific model
-./remove-background.sh photo.jpg briaai
-
-# With custom output and resolution
-./remove-background.sh photo.jpg briaai output.png 4096
-```
-
-**Arguments:**
-- `input` - Input image file (required)
-- `model` - Model name: u2netp, modnet, briaai, isnet-anime, silueta, u2net-cloth (default: modnet)
-- `output` - Output file path (default: auto-generated)
-- `resolution` - Max resolution in pixels (default: 2048)
-
-### batch-remove-background.sh
-Remove backgrounds from all images in a directory.
-
-```bash
-# Basic usage
-./batch-remove-background.sh ./photos
-
-# With custom output directory
-./batch-remove-background.sh ./photos ./output
-
-# With specific model and resolution
-./batch-remove-background.sh ./photos ./output briaai 4096
-```
-
-**Arguments:**
-- `input_dir` - Input directory with images (required)
-- `output_dir` - Output directory (default: input_dir/no-bg)
-- `model` - Model name (default: modnet)
-- `resolution` - Max resolution in pixels (default: 2048)
-
-### remove-bg-node.js
-Node.js script for background removal with progress tracking.
-
-```bash
-# Basic usage
-node remove-bg-node.js photo.jpg
-
-# With options
-node remove-bg-node.js photo.jpg -m briaai -o output.png -r 4096 -p
-```
-
-**Options:**
-- `-o, --output <path>` - Output file path
-- `-m, --model <name>` - Model: briaai, modnet, u2netp
-- `-r, --resolution <n>` - Max resolution
-- `-p, --progress` - Show progress
-
-## Image Processing Scripts
-
-### batch_resize.py
-Batch resize images with various options.
-
-```bash
-python batch_resize.py -i ./input -o ./output -w 800 -h 600
-```
-
-## Video Processing Scripts
-
-### video_optimize.py
-Optimize videos for web with quality and size optimization.
-
-```bash
-python video_optimize.py -i input.mp4 -o output.mp4 --preset slow --crf 23
-```
-
-### media_convert.py
-Convert media files between different formats.
-
-```bash
-python media_convert.py -i input.mkv -o output.mp4 --codec h264
-```
-
-## Requirements
-
-### Shell Scripts
-- Bash (macOS, Linux)
-- rmbg-cli: `npm install -g rmbg-cli`
-- FFmpeg: `brew install ffmpeg` or `apt-get install ffmpeg`
-- ImageMagick: `brew install imagemagick` or `apt-get install imagemagick`
-
-### Node.js Scripts
-- Node.js 14+
-- Dependencies: `npm install rmbg`
-
-### Python Scripts
-- Python 3.7+
-- Dependencies: `pip install -r requirements.txt`
-
-## Testing
-
-Run tests:
-```bash
-cd tests
-bash test_all.sh
-```

package/templates/repo/.github/skills/ck-media-processing/scripts/batch-remove-background.sh

@@ -1,124 +0,0 @@
-#!/bin/bash
-# Batch background removal script using RMBG CLI
-# Usage: ./batch-remove-background.sh <input_dir> [output_dir] [model] [resolution]
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Default values
-INPUT_DIR=""
-OUTPUT_DIR=""
-MODEL="modnet"
-MAX_RESOLUTION="2048"
-
-# Parse arguments
-INPUT_DIR="$1"
-if [ -n "$2" ]; then
-    OUTPUT_DIR="$2"
-fi
-if [ -n "$3" ]; then
-    MODEL="$3"
-fi
-if [ -n "$4" ]; then
-    MAX_RESOLUTION="$4"
-fi
-
-# Validate input directory
-if [ -z "$INPUT_DIR" ]; then
-    echo -e "${RED}Error: Input directory is required${NC}"
-    echo ""
-    echo "Usage: $0 <input_dir> [output_dir] [model] [resolution]"
-    echo ""
-    echo "Arguments:"
-    echo "  input_dir   Input directory with images (required)"
-    echo "  output_dir  Output directory (default: input_dir/no-bg)"
-    echo "  model       Model name: u2netp, modnet, briaai, isnet-anime, silueta, u2net-cloth (default: modnet)"
-    echo "  resolution  Max resolution in pixels (default: 2048)"
-    echo ""
-    echo "Examples:"
-    echo "  $0 ./photos"
-    echo "  $0 ./photos ./output"
-    echo "  $0 ./photos ./output briaai"
-    echo "  $0 ./photos ./output briaai 4096"
-    exit 1
-fi
-
-if [ ! -d "$INPUT_DIR" ]; then
-    echo -e "${RED}Error: Input directory '$INPUT_DIR' not found${NC}"
-    exit 1
-fi
-
-# Set default output directory
-if [ -z "$OUTPUT_DIR" ]; then
-    OUTPUT_DIR="$INPUT_DIR/no-bg"
-fi
-
-# Create output directory if it doesn't exist
-mkdir -p "$OUTPUT_DIR"
-
-# Check if rmbg-cli is installed
-if ! command -v rmbg &> /dev/null; then
-    echo -e "${YELLOW}Warning: rmbg-cli not found${NC}"
-    echo "Installing rmbg-cli globally..."
-    npm install -g rmbg-cli
-    echo -e "${GREEN}✓ rmbg-cli installed${NC}"
-fi
-
-# Find all image files
-IMAGE_FILES=$(find "$INPUT_DIR" -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.webp" \))
-TOTAL_FILES=$(echo "$IMAGE_FILES" | grep -v '^$' | wc -l | tr -d ' ')
-
-if [ "$TOTAL_FILES" -eq 0 ]; then
-    echo -e "${YELLOW}Warning: No image files found in '$INPUT_DIR'${NC}"
-    exit 0
-fi
-
-# Display configuration
-echo -e "${GREEN}Batch Background Removal Configuration:${NC}"
-echo "  Input Dir:  $INPUT_DIR"
-echo "  Output Dir: $OUTPUT_DIR"
-echo "  Model:      $MODEL"
-echo "  Resolution: $MAX_RESOLUTION"
-echo "  Total Files: $TOTAL_FILES"
-echo ""
-
-# Process each image
-SUCCESS_COUNT=0
-FAIL_COUNT=0
-CURRENT=0
-
-while IFS= read -r file; do
-    [ -z "$file" ] && continue
-
-    CURRENT=$((CURRENT + 1))
-    BASENAME=$(basename "$file")
-    OUTPUT_FILE="$OUTPUT_DIR/${BASENAME%.*}.png"
-
-    echo -e "${BLUE}[$CURRENT/$TOTAL_FILES]${NC} Processing: $BASENAME"
-
-    if rmbg "$file" -m "$MODEL" -o "$OUTPUT_FILE" -r "$MAX_RESOLUTION" 2>/dev/null; then
-        SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
-        echo -e "  ${GREEN}✓ Success${NC}"
-    else
-        FAIL_COUNT=$((FAIL_COUNT + 1))
-        echo -e "  ${RED}✗ Failed${NC}"
-    fi
-done <<< "$IMAGE_FILES"
-
-# Display summary
-echo ""
-echo -e "${GREEN}Batch Processing Complete${NC}"
-echo "  Total:   $TOTAL_FILES files"
-echo "  Success: $SUCCESS_COUNT files"
-echo "  Failed:  $FAIL_COUNT files"
-echo "  Output:  $OUTPUT_DIR"
-
-if [ "$FAIL_COUNT" -gt 0 ]; then
-    exit 1
-fi

package/templates/repo/.github/skills/ck-media-processing/scripts/batch_resize.py

@@ -1,342 +0,0 @@
-#!/usr/bin/env python3
-"""
-Batch image resizing with multiple strategies.
-
-Supports aspect ratio maintenance, smart cropping, thumbnail generation,
-watermarks, format conversion, and parallel processing.
-"""
-
-import argparse
-import subprocess
-import sys
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-from typing import List, Optional, Tuple
-
-
-class ImageResizer:
-    """Handle image resizing operations using ImageMagick."""
-
-    def __init__(self, verbose: bool = False, dry_run: bool = False):
-        self.verbose = verbose
-        self.dry_run = dry_run
-
-    def check_imagemagick(self) -> bool:
-        """Check if ImageMagick is available."""
-        try:
-            subprocess.run(
-                ['magick', '-version'],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                check=True
-            )
-            return True
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            return False
-
-    def build_resize_command(
-        self,
-        input_path: Path,
-        output_path: Path,
-        width: Optional[int],
-        height: Optional[int],
-        strategy: str,
-        quality: int,
-        watermark: Optional[Path] = None
-    ) -> List[str]:
-        """Build ImageMagick resize command based on strategy."""
-        cmd = ['magick', str(input_path)]
-
-        # Apply resize strategy
-        if strategy == 'fit':
-            # Fit within dimensions, maintain aspect ratio
-            geometry = f"{width or ''}x{height or ''}"
-            cmd.extend(['-resize', geometry])
-
-        elif strategy == 'fill':
-            # Fill dimensions, crop excess
-            if not width or not height:
-                raise ValueError("Both width and height required for 'fill' strategy")
-            cmd.extend([
-                '-resize', f'{width}x{height}^',
-                '-gravity', 'center',
-                '-extent', f'{width}x{height}'
-            ])
-
-        elif strategy == 'cover':
-            # Cover dimensions, may exceed
-            if not width or not height:
-                raise ValueError("Both width and height required for 'cover' strategy")
-            cmd.extend(['-resize', f'{width}x{height}^'])
-
-        elif strategy == 'exact':
-            # Force exact dimensions, ignore aspect ratio
-            if not width or not height:
-                raise ValueError("Both width and height required for 'exact' strategy")
-            cmd.extend(['-resize', f'{width}x{height}!'])
-
-        elif strategy == 'thumbnail':
-            # Create square thumbnail
-            size = width or height or 200
-            cmd.extend([
-                '-resize', f'{size}x{size}^',
-                '-gravity', 'center',
-                '-extent', f'{size}x{size}'
-            ])
-
-        # Add watermark if specified
-        if watermark:
-            cmd.extend([
-                str(watermark),
-                '-gravity', 'southeast',
-                '-geometry', '+10+10',
-                '-composite'
-            ])
-
-        # Output settings
-        cmd.extend([
-            '-quality', str(quality),
-            '-strip',
-            str(output_path)
-        ])
-
-        return cmd
-
-    def resize_image(
-        self,
-        input_path: Path,
-        output_path: Path,
-        width: Optional[int],
-        height: Optional[int],
-        strategy: str = 'fit',
-        quality: int = 85,
-        watermark: Optional[Path] = None
-    ) -> bool:
-        """Resize a single image."""
-        try:
-            # Ensure output directory exists
-            output_path.parent.mkdir(parents=True, exist_ok=True)
-
-            cmd = self.build_resize_command(
-                input_path, output_path, width, height,
-                strategy, quality, watermark
-            )
-
-            if self.verbose or self.dry_run:
-                print(f"Command: {' '.join(cmd)}")
-
-            if self.dry_run:
-                return True
-
-            subprocess.run(
-                cmd,
-                stdout=subprocess.PIPE if not self.verbose else None,
-                stderr=subprocess.PIPE if not self.verbose else None,
-                check=True
-            )
-            return True
-
-        except subprocess.CalledProcessError as e:
-            print(f"Error resizing {input_path}: {e}", file=sys.stderr)
-            if not self.verbose and e.stderr:
-                print(e.stderr.decode(), file=sys.stderr)
-            return False
-        except Exception as e:
-            print(f"Error processing {input_path}: {e}", file=sys.stderr)
-            return False
-
-    def batch_resize(
-        self,
-        input_paths: List[Path],
-        output_dir: Path,
-        width: Optional[int],
-        height: Optional[int],
-        strategy: str = 'fit',
-        quality: int = 85,
-        format_ext: Optional[str] = None,
-        watermark: Optional[Path] = None,
-        parallel: int = 1
-    ) -> Tuple[int, int]:
-        """Resize multiple images."""
-        success_count = 0
-        fail_count = 0
-
-        def process_image(input_path: Path) -> Tuple[Path, bool]:
-            """Process single image for parallel execution."""
-            if not input_path.exists() or not input_path.is_file():
-                return input_path, False
-
-            # Determine output path
-            output_name = input_path.stem
-            if format_ext:
-                output_path = output_dir / f"{output_name}.{format_ext.lstrip('.')}"
-            else:
-                output_path = output_dir / input_path.name
-
-            if not self.dry_run:
-                print(f"Processing {input_path.name} -> {output_path.name}")
-
-            success = self.resize_image(
-                input_path, output_path, width, height,
-                strategy, quality, watermark
-            )
-
-            return input_path, success
-
-        # Process images
-        if parallel > 1:
-            with ThreadPoolExecutor(max_workers=parallel) as executor:
-                futures = [executor.submit(process_image, path) for path in input_paths]
-
-                for future in as_completed(futures):
-                    _, success = future.result()
-                    if success:
-                        success_count += 1
-                    else:
-                        fail_count += 1
-        else:
-            for input_path in input_paths:
-                _, success = process_image(input_path)
-                if success:
-                    success_count += 1
-                else:
-                    fail_count += 1
-
-        return success_count, fail_count
-
-
-def collect_images(paths: List[Path], recursive: bool = False) -> List[Path]:
-    """Collect image files from paths."""
-    image_exts = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff', '.tif'}
-    images = []
-
-    for path in paths:
-        if path.is_file() and path.suffix.lower() in image_exts:
-            images.append(path)
-        elif path.is_dir():
-            pattern = '**/*' if recursive else '*'
-            for img_path in path.glob(pattern):
-                if img_path.is_file() and img_path.suffix.lower() in image_exts:
-                    images.append(img_path)
-
-    return images
-
-
-def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description='Batch image resizing with multiple strategies.'
-    )
-    parser.add_argument(
-        'inputs',
-        nargs='+',
-        type=Path,
-        help='Input image(s) or directory'
-    )
-    parser.add_argument(
-        '-o', '--output',
-        type=Path,
-        required=True,
-        help='Output directory'
-    )
-    parser.add_argument(
-        '-w', '--width',
-        type=int,
-        help='Target width in pixels'
-    )
-    parser.add_argument(
-        '-h', '--height',
-        type=int,
-        dest='img_height',
-        help='Target height in pixels'
-    )
-    parser.add_argument(
-        '-s', '--strategy',
-        choices=['fit', 'fill', 'cover', 'exact', 'thumbnail'],
-        default='fit',
-        help='Resize strategy (default: fit)'
-    )
-    parser.add_argument(
-        '-q', '--quality',
-        type=int,
-        default=85,
-        help='Output quality 0-100 (default: 85)'
-    )
-    parser.add_argument(
-        '-f', '--format',
-        help='Output format (e.g., jpg, png, webp)'
-    )
-    parser.add_argument(
-        '-wm', '--watermark',
-        type=Path,
-        help='Watermark image to overlay'
-    )
-    parser.add_argument(
-        '-p', '--parallel',
-        type=int,
-        default=1,
-        help='Number of parallel processes (default: 1)'
-    )
-    parser.add_argument(
-        '-r', '--recursive',
-        action='store_true',
-        help='Process directories recursively'
-    )
-    parser.add_argument(
-        '-n', '--dry-run',
-        action='store_true',
-        help='Show commands without executing'
-    )
-    parser.add_argument(
-        '-v', '--verbose',
-        action='store_true',
-        help='Verbose output'
-    )
-
-    args = parser.parse_args()
-
-    # Validate dimensions
-    if not args.width and not args.img_height:
-        print("Error: At least one of --width or --height required", file=sys.stderr)
-        sys.exit(1)
-
-    # Initialize resizer
-    resizer = ImageResizer(verbose=args.verbose, dry_run=args.dry_run)
-
-    # Check dependencies
-    if not resizer.check_imagemagick():
-        print("Error: ImageMagick not found", file=sys.stderr)
-        sys.exit(1)
-
-    # Collect input images
-    images = collect_images(args.inputs, args.recursive)
-
-    if not images:
-        print("Error: No images found", file=sys.stderr)
-        sys.exit(1)
-
-    print(f"Found {len(images)} image(s) to process")
-
-    # Create output directory
-    if not args.dry_run:
-        args.output.mkdir(parents=True, exist_ok=True)
-
-    # Process images
-    success, fail = resizer.batch_resize(
-        images,
-        args.output,
-        args.width,
-        args.img_height,
-        args.strategy,
-        args.quality,
-        args.format,
-        args.watermark,
-        args.parallel
-    )
-
-    print(f"\nResults: {success} succeeded, {fail} failed")
-    sys.exit(0 if fail == 0 else 1)
-
-
-if __name__ == '__main__':
-    main()