@macpaw/cctk 1.0.0-beta.1

package/templates/claude/skills/media-processing/scripts/media_convert.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Unified media conversion tool for video, audio, and images.
+
+Auto-detects format and applies appropriate tool (FFmpeg or ImageMagick).
+Supports quality presets, batch processing, and dry-run mode.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+# Format mappings
+VIDEO_FORMATS = {'.mp4', '.mkv', '.avi', '.mov', '.webm', '.flv', '.wmv', '.m4v'}
+AUDIO_FORMATS = {'.mp3', '.aac', '.m4a', '.opus', '.flac', '.wav', '.ogg'}
+IMAGE_FORMATS = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff', '.tif'}
+
+# Quality presets
+QUALITY_PRESETS = {
+    'web': {
+        'video_crf': 23,
+        'video_preset': 'medium',
+        'audio_bitrate': '128k',
+        'image_quality': 85
+    },
+    'archive': {
+        'video_crf': 18,
+        'video_preset': 'slow',
+        'audio_bitrate': '192k',
+        'image_quality': 95
+    },
+    'mobile': {
+        'video_crf': 26,
+        'video_preset': 'fast',
+        'audio_bitrate': '96k',
+        'image_quality': 80
+    }
+}
+
+
+def check_dependencies() -> Tuple[bool, bool]:
+    """Check if ffmpeg and imagemagick are available."""
+    ffmpeg_available = subprocess.run(
+        ['ffmpeg', '-version'],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    ).returncode == 0
+
+    magick_available = subprocess.run(
+        ['magick', '-version'],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    ).returncode == 0
+
+    return ffmpeg_available, magick_available
+
+
+def detect_media_type(file_path: Path) -> str:
+    """Detect media type from file extension."""
+    ext = file_path.suffix.lower()
+
+    if ext in VIDEO_FORMATS:
+        return 'video'
+    elif ext in AUDIO_FORMATS:
+        return 'audio'
+    elif ext in IMAGE_FORMATS:
+        return 'image'
+    else:
+        return 'unknown'
+
+
+def build_video_command(
+    input_path: Path,
+    output_path: Path,
+    preset: str = 'web'
+) -> List[str]:
+    """Build FFmpeg command for video conversion."""
+    quality = QUALITY_PRESETS[preset]
+
+    return [
+        'ffmpeg', '-i', str(input_path),
+        '-c:v', 'libx264',
+        '-preset', quality['video_preset'],
+        '-crf', str(quality['video_crf']),
+        '-c:a', 'aac',
+        '-b:a', quality['audio_bitrate'],
+        '-movflags', '+faststart',
+        '-y',
+        str(output_path)
+    ]
+
+
+def build_audio_command(
+    input_path: Path,
+    output_path: Path,
+    preset: str = 'web'
+) -> List[str]:
+    """Build FFmpeg command for audio conversion."""
+    quality = QUALITY_PRESETS[preset]
+    output_ext = output_path.suffix.lower()
+
+    codec_map = {
+        '.mp3': 'libmp3lame',
+        '.aac': 'aac',
+        '.m4a': 'aac',
+        '.opus': 'libopus',
+        '.flac': 'flac',
+        '.wav': 'pcm_s16le',
+        '.ogg': 'libvorbis'
+    }
+
+    codec = codec_map.get(output_ext, 'aac')
+
+    cmd = ['ffmpeg', '-i', str(input_path), '-c:a', codec]
+
+    # Add bitrate for lossy codecs
+    if codec not in ['flac', 'pcm_s16le']:
+        cmd.extend(['-b:a', quality['audio_bitrate']])
+
+    cmd.extend(['-y', str(output_path)])
+    return cmd
+
+
+def build_image_command(
+    input_path: Path,
+    output_path: Path,
+    preset: str = 'web'
+) -> List[str]:
+    """Build ImageMagick command for image conversion."""
+    quality = QUALITY_PRESETS[preset]
+
+    return [
+        'magick', str(input_path),
+        '-quality', str(quality['image_quality']),
+        '-strip',
+        str(output_path)
+    ]
+
+
+def convert_file(
+    input_path: Path,
+    output_path: Path,
+    preset: str = 'web',
+    dry_run: bool = False,
+    verbose: bool = False
+) -> bool:
+    """Convert a single media file."""
+    media_type = detect_media_type(input_path)
+
+    if media_type == 'unknown':
+        print(f"Error: Unsupported format for {input_path}", file=sys.stderr)
+        return False
+
+    # Ensure output directory exists
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Build command based on media type
+    if media_type == 'video':
+        cmd = build_video_command(input_path, output_path, preset)
+    elif media_type == 'audio':
+        cmd = build_audio_command(input_path, output_path, preset)
+    else:  # image
+        cmd = build_image_command(input_path, output_path, preset)
+
+    if verbose or dry_run:
+        print(f"Command: {' '.join(cmd)}")
+
+    if dry_run:
+        return True
+
+    try:
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE if not verbose else None,
+            stderr=subprocess.PIPE if not verbose else None,
+            check=True
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error converting {input_path}: {e}", file=sys.stderr)
+        if not verbose and e.stderr:
+            print(e.stderr.decode(), file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Error converting {input_path}: {e}", file=sys.stderr)
+        return False
+
+
+def batch_convert(
+    input_paths: List[Path],
+    output_dir: Optional[Path] = None,
+    output_format: Optional[str] = None,
+    preset: str = 'web',
+    dry_run: bool = False,
+    verbose: bool = False
+) -> Tuple[int, int]:
+    """Convert multiple files."""
+    success_count = 0
+    fail_count = 0
+
+    for input_path in input_paths:
+        if not input_path.exists():
+            print(f"Error: {input_path} not found", file=sys.stderr)
+            fail_count += 1
+            continue
+
+        # Determine output path
+        if output_dir:
+            output_name = input_path.stem
+            if output_format:
+                output_path = output_dir / f"{output_name}.{output_format.lstrip('.')}"
+            else:
+                output_path = output_dir / input_path.name
+        else:
+            if output_format:
+                output_path = input_path.with_suffix(f".{output_format.lstrip('.')}")
+            else:
+                print(f"Error: No output format specified for {input_path}", file=sys.stderr)
+                fail_count += 1
+                continue
+
+        print(f"Converting {input_path.name} -> {output_path.name}")
+
+        if convert_file(input_path, output_path, preset, dry_run, verbose):
+            success_count += 1
+        else:
+            fail_count += 1
+
+    return success_count, fail_count
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description='Unified media conversion tool for video, audio, and images.'
+    )
+    parser.add_argument(
+        'inputs',
+        nargs='+',
+        type=Path,
+        help='Input file(s) to convert'
+    )
+    parser.add_argument(
+        '-o', '--output',
+        type=Path,
+        help='Output file or directory for batch conversion'
+    )
+    parser.add_argument(
+        '-f', '--format',
+        help='Output format (e.g., mp4, jpg, mp3)'
+    )
+    parser.add_argument(
+        '-p', '--preset',
+        choices=['web', 'archive', 'mobile'],
+        default='web',
+        help='Quality preset (default: web)'
+    )
+    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()
+
+    # Check dependencies
+    ffmpeg_ok, magick_ok = check_dependencies()
+    if not ffmpeg_ok and not magick_ok:
+        print("Error: Neither ffmpeg nor imagemagick found", file=sys.stderr)
+        sys.exit(1)
+
+    # Handle single file vs batch conversion
+    if len(args.inputs) == 1 and args.output and not args.output.is_dir():
+        # Single file conversion
+        success = convert_file(
+            args.inputs[0],
+            args.output,
+            args.preset,
+            args.dry_run,
+            args.verbose
+        )
+        sys.exit(0 if success else 1)
+    else:
+        # Batch conversion
+        output_dir = args.output if args.output else Path.cwd()
+        if not args.output:
+            output_dir = None  # Will convert in place with new format
+
+        success, fail = batch_convert(
+            args.inputs,
+            output_dir,
+            args.format,
+            args.preset,
+            args.dry_run,
+            args.verbose
+        )
+
+        print(f"\nResults: {success} succeeded, {fail} failed")
+        sys.exit(0 if fail == 0 else 1)
+
+
+if __name__ == '__main__':
+    main()

package/templates/claude/skills/media-processing/scripts/remove-background.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+# Background removal script using RMBG CLI
+# Usage: ./remove-background.sh <input> [model] [output] [resolution]
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Default values
+INPUT=""
+MODEL="modnet"
+OUTPUT=""
+MAX_RESOLUTION="2048"
+
+# Parse arguments
+INPUT="$1"
+if [ -n "$2" ]; then
+    MODEL="$2"
+fi
+if [ -n "$3" ]; then
+    OUTPUT="$3"
+fi
+if [ -n "$4" ]; then
+    MAX_RESOLUTION="$4"
+fi
+
+# Validate input
+if [ -z "$INPUT" ]; then
+    echo -e "${RED}Error: Input file is required${NC}"
+    echo ""
+    echo "Usage: $0 <input> [model] [output] [resolution]"
+    echo ""
+    echo "Arguments:"
+    echo "  input       Input image file (required)"
+    echo "  model       Model name: u2netp, modnet, briaai, isnet-anime, silueta, u2net-cloth (default: modnet)"
+    echo "  output      Output file path (default: auto-generated)"
+    echo "  resolution  Max resolution in pixels (default: 2048)"
+    echo ""
+    echo "Examples:"
+    echo "  $0 photo.jpg"
+    echo "  $0 photo.jpg briaai"
+    echo "  $0 photo.jpg briaai output.png"
+    echo "  $0 photo.jpg briaai output.png 4096"
+    exit 1
+fi
+
+if [ ! -f "$INPUT" ]; then
+    echo -e "${RED}Error: Input file '$INPUT' not found${NC}"
+    exit 1
+fi
+
+# 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
+
+# Generate output filename if not provided
+if [ -z "$OUTPUT" ]; then
+    BASENAME=$(basename "$INPUT" | sed 's/\.[^.]*$//')
+    OUTPUT="${BASENAME}-no-bg.png"
+fi
+
+# Display configuration
+echo -e "${GREEN}Background Removal Configuration:${NC}"
+echo "  Input:      $INPUT"
+echo "  Model:      $MODEL"
+echo "  Output:     $OUTPUT"
+echo "  Resolution: $MAX_RESOLUTION"
+echo ""
+
+# Remove background
+echo "Processing..."
+rmbg "$INPUT" -m "$MODEL" -o "$OUTPUT" -r "$MAX_RESOLUTION"
+
+if [ $? -eq 0 ]; then
+    echo -e "${GREEN}✓ Background removed successfully${NC}"
+    echo "  Output: $OUTPUT"
+
+    # Display file sizes
+    INPUT_SIZE=$(du -h "$INPUT" | cut -f1)
+    OUTPUT_SIZE=$(du -h "$OUTPUT" | cut -f1)
+    echo ""
+    echo "File sizes:"
+    echo "  Input:  $INPUT_SIZE"
+    echo "  Output: $OUTPUT_SIZE"
+else
+    echo -e "${RED}✗ Background removal failed${NC}"
+    exit 1
+fi

package/templates/claude/skills/media-processing/scripts/remove-bg-node.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+/**
+ * Node.js background removal script using RMBG SDK
+ * Usage: node remove-bg-node.js <input> [options]
+ */
+
+const { readFileSync, writeFileSync, existsSync } = require('node:fs');
+const { basename, extname } = require('node:path');
+const { rmbg, createBriaaiModel, createModnetModel, createU2netpModel } = require('rmbg');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  console.log(`
+Background Removal using RMBG SDK
+
+Usage: node remove-bg-node.js <input> [options]
+
+Arguments:
+  input               Input image file path (required)
+
+Options:
+  -o, --output <path>     Output file path (default: auto-generated)
+  -m, --model <name>      Model: briaai, modnet, u2netp (default: modnet)
+  -r, --resolution <n>    Max resolution in pixels (default: 2048)
+  -p, --progress          Show progress information
+  -h, --help              Show this help message
+
+Examples:
+  node remove-bg-node.js photo.jpg
+  node remove-bg-node.js photo.jpg -m briaai -o output.png
+  node remove-bg-node.js photo.jpg -r 4096 -p
+`);
+  process.exit(0);
+}
+
+// Parse options
+const input = args[0];
+let output = null;
+let model = 'modnet';
+let maxResolution = 2048;
+let showProgress = false;
+
+for (let i = 1; i < args.length; i++) {
+  const arg = args[i];
+
+  switch (arg) {
+    case '-o':
+    case '--output': {
+      output = args[++i];
+
+      break;
+    }
+    case '-m':
+    case '--model': {
+      model = args[++i];
+
+      break;
+    }
+    case '-r':
+    case '--resolution': {
+      maxResolution = Number.parseInt(args[++i], 10);
+
+      break;
+    }
+    case '-p':
+    case '--progress': {
+      showProgress = true;
+
+      break;
+    }
+    // No default
+  }
+}
+
+// Validate input
+if (!input) {
+  console.error('Error: Input file is required');
+  process.exit(1);
+}
+
+if (!existsSync(input)) {
+  console.error(`Error: Input file '${input}' not found`);
+  process.exit(1);
+}
+
+// Generate output filename if not provided
+if (!output) {
+  const name = basename(input, extname(input));
+
+  output = `${name}-no-bg.png`;
+}
+
+// Select model
+let modelInstance;
+
+switch (model.toLowerCase()) {
+  case 'briaai': {
+    modelInstance = createBriaaiModel();
+    break;
+  }
+  case 'u2netp': {
+    modelInstance = createU2netpModel();
+    break;
+  }
+  case 'modnet':
+  default: {
+    modelInstance = createModnetModel();
+    break;
+  }
+}
+
+// Display configuration
+console.log('Background Removal Configuration:');
+console.log(`  Input:      ${input}`);
+console.log(`  Model:      ${model}`);
+console.log(`  Output:     ${output}`);
+console.log(`  Resolution: ${maxResolution}`);
+console.log('');
+
+// Remove background
+async function removeBackground() {
+  try {
+    console.log('Processing...');
+    const startTime = Date.now();
+
+    const options = {
+      model: modelInstance,
+      maxResolution,
+      output,
+    };
+
+    if (showProgress) {
+      options.onProgress = (progress, download, process) => {
+        const percent = Math.round(progress * 100);
+        const downloadPercent = Math.round(download * 100);
+        const processPercent = Math.round(process * 100);
+
+        process.stdout.write(`\rProgress: ${percent}% | Download: ${downloadPercent}% | Process: ${processPercent}%`);
+      };
+    }
+
+    await rmbg(input, options);
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    if (showProgress) {
+      console.log(''); // New line after progress
+    }
+
+    console.log('✓ Background removed successfully');
+    console.log(`  Output: ${output}`);
+    console.log(`  Duration: ${duration}s`);
+
+    // Display file sizes
+    const inputStats = require('node:fs').statSync(input);
+    const outputStats = require('node:fs').statSync(output);
+
+    console.log('');
+    console.log('File sizes:');
+    console.log(`  Input:  ${formatBytes(inputStats.size)}`);
+    console.log(`  Output: ${formatBytes(outputStats.size)}`);
+  } catch (error) {
+    console.error('✗ Background removal failed:', error.message);
+    process.exit(1);
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${Math.round((bytes / k ** i) * 100) / 100} ${sizes[i]}`;
+}
+
+// Run
+removeBackground();

package/templates/claude/skills/mermaidjs-v11/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: mermaidjs-v11
+description: Create diagrams and visualizations using Mermaid.js v11 syntax. Use when generating flowcharts, sequence diagrams, class diagrams, state diagrams, ER diagrams, Gantt charts, user journeys, timelines, architecture diagrams, or any of 24+ diagram types. Supports JavaScript API integration, CLI rendering to SVG/PNG/PDF, theming, configuration, and accessibility features. Essential for documentation, technical diagrams, project planning, system architecture, and visual communication.
+---
+
+# Mermaid.js v11
+
+## Overview
+
+Create text-based diagrams using Mermaid.js v11 declarative syntax. Convert code to SVG/PNG/PDF via CLI or render in browsers/markdown files.
+
+## Quick Start
+
+**Basic Diagram Structure:**
+```
+{diagram-type}
+  {diagram-content}
+```
+
+**Common Diagram Types:**
+- `flowchart` - Process flows, decision trees
+- `sequenceDiagram` - Actor interactions, API flows
+- `classDiagram` - OOP structures, data models
+- `stateDiagram` - State machines, workflows
+- `erDiagram` - Database relationships
+- `gantt` - Project timelines
+- `journey` - User experience flows
+
+See `references/diagram-types.md` for all 24+ types with syntax.
+
+## Creating Diagrams
+
+**Inline Markdown Code Blocks:**
+````markdown
+```mermaid
+flowchart TD
+    A[Start] --> B{Decision}
+    B -->|Yes| C[Action]
+    B -->|No| D[End]
+```
+````
+
+**Configuration via Frontmatter:**
+````markdown
+```mermaid
+---
+theme: dark
+---
+flowchart LR
+    A --> B
+```
+````
+
+**Comments:** Use `%% ` prefix for single-line comments.
+
+## CLI Usage
+
+Convert `.mmd` files to images:
+```bash
+# Installation
+npm install -g @mermaid-js/mermaid-cli
+
+# Basic conversion
+mmdc -i diagram.mmd -o diagram.svg
+
+# With theme and background
+mmdc -i input.mmd -o output.png -t dark -b transparent
+
+# Custom styling
+mmdc -i diagram.mmd --cssFile style.css -o output.svg
+```
+
+See `references/cli-usage.md` for Docker, batch processing, and advanced workflows.
+
+## JavaScript Integration
+
+**HTML Embedding:**
+```html
+<pre class="mermaid">
+  flowchart TD
+    A[Client] --> B[Server]
+</pre>
+<script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
+<script>mermaid.initialize({ startOnLoad: true });</script>
+```
+
+See `references/integration.md` for Node.js API and advanced integration patterns.
+
+## Configuration & Theming
+
+**Common Options:**
+- `theme`: "default", "dark", "forest", "neutral", "base"
+- `look`: "classic", "handDrawn"
+- `fontFamily`: Custom font specification
+- `securityLevel`: "strict", "loose", "antiscript"
+
+See `references/configuration.md` for complete config options, theming, and customization.
+
+## Practical Patterns
+
+Load `references/examples.md` for:
+- Architecture diagrams
+- API documentation flows
+- Database schemas
+- Project timelines
+- State machines
+- User journey maps
+
+## Resources
+
+- `references/diagram-types.md` - Syntax for all 24+ diagram types
+- `references/configuration.md` - Config, theming, accessibility
+- `references/cli-usage.md` - CLI commands and workflows
+- `references/integration.md` - JavaScript API and embedding
+- `references/examples.md` - Practical patterns and use cases