claude-code-arcane 1.0.0

package/skills/frontend-dev/scripts/minimax_music.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+MiniMax Music Generation (HTTP)
+Self-contained: no external dependencies beyond `requests`.
+
+Usage:
+  python minimax_music.py --prompt "Indie folk, melancholic" --lyrics "[verse]\nStreetlights flicker" -o song.mp3
+  python minimax_music.py --prompt "Upbeat pop, energetic" --auto-lyrics -o pop.mp3
+  python minimax_music.py --prompt "Jazz piano, smooth, relaxing" --instrumental -o jazz.mp3
+
+Env: MINIMAX_API_KEY (required)
+"""
+
+import os
+import sys
+import json
+import argparse
+import requests
+
+API_KEY = os.getenv("MINIMAX_API_KEY")
+# China Mainland: https://api.minimaxi.com/v1
+# Overseas:       https://api.minimax.io/v1
+API_BASE = os.getenv("MINIMAX_API_BASE")
+if not API_BASE:
+    raise SystemExit("ERROR: MINIMAX_API_BASE is not set.")
+
+
+def generate_music(
+    prompt: str = "",
+    lyrics: str = "",
+    model: str = "music-2.5+",
+    is_instrumental: bool = False,
+    lyrics_optimizer: bool = False,
+    sample_rate: int = 44100,
+    bitrate: int = 256000,
+    fmt: str = "mp3",
+    output_format: str = "hex",
+    timeout: int = 600,
+) -> dict:
+    """Synchronous HTTP music generation. Returns dict with audio bytes and metadata."""
+    if not API_KEY:
+        raise SystemExit("ERROR: MINIMAX_API_KEY is not set.\n  export MINIMAX_API_KEY='your-key'")
+
+    payload = {
+        "model": model,
+        "audio_setting": {
+            "sample_rate": sample_rate,
+            "bitrate": bitrate,
+            "format": fmt,
+        },
+        "output_format": output_format,
+    }
+
+    if prompt:
+        payload["prompt"] = prompt
+    if lyrics:
+        payload["lyrics"] = lyrics
+    if is_instrumental:
+        payload["is_instrumental"] = True
+    if lyrics_optimizer:
+        payload["lyrics_optimizer"] = True
+
+    resp = requests.post(
+        f"{API_BASE}/music_generation",
+        headers={
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json",
+        },
+        json=payload,
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    # Check API-level error
+    base_resp = data.get("base_resp", {})
+    if base_resp.get("status_code", 0) != 0:
+        raise SystemExit(f"API Error [{base_resp.get('status_code')}]: {base_resp.get('status_msg')}")
+
+    status = data.get("data", {}).get("status")
+    if status != 2:
+        raise SystemExit(f"Generation incomplete (status={status}): {json.dumps(data, indent=2)}")
+
+    audio_data = data.get("data", {}).get("audio", "")
+    if not audio_data:
+        raise SystemExit(f"No audio in response: {json.dumps(data, indent=2)}")
+
+    extra = data.get("extra_info", {})
+
+    if output_format == "hex":
+        audio_bytes = bytes.fromhex(audio_data)
+    else:
+        # URL mode — audio_data is a URL string
+        audio_bytes = None
+
+    return {
+        "audio_bytes": audio_bytes,
+        "audio_url": audio_data if output_format == "url" else None,
+        "duration": extra.get("music_duration"),
+        "sample_rate": extra.get("music_sample_rate"),
+        "channels": extra.get("music_channel"),
+        "bitrate": extra.get("bitrate"),
+        "size": extra.get("music_size"),
+    }
+
+
+def main():
+    p = argparse.ArgumentParser(description="MiniMax Music Generation (HTTP)")
+    p.add_argument("-o", "--output", required=True, help="Output file path")
+    p.add_argument("--prompt", default="", help="Music description: style, mood, scenario (max 2000 chars)")
+    p.add_argument("--lyrics", default="", help="Song lyrics with structure tags (max 3500 chars)")
+    p.add_argument("--lyrics-file", default="", help="Read lyrics from file instead of --lyrics")
+    p.add_argument("--model", default="music-2.5+", choices=["music-2.5+", "music-2.5"], help="Model (default: music-2.5+)")
+    p.add_argument("--instrumental", action="store_true", help="Generate instrumental only (no vocals)")
+    p.add_argument("--auto-lyrics", action="store_true", help="Auto-generate lyrics from prompt")
+    p.add_argument("--format", default="mp3", dest="fmt", choices=["mp3", "wav", "pcm"], help="Audio format (default: mp3)")
+    p.add_argument("--sample-rate", type=int, default=44100, choices=[16000, 24000, 32000, 44100], help="Sample rate (default: 44100)")
+    p.add_argument("--bitrate", type=int, default=256000, choices=[32000, 64000, 128000, 256000], help="Bitrate (default: 256000)")
+    args = p.parse_args()
+
+    lyrics = args.lyrics
+    if args.lyrics_file:
+        with open(args.lyrics_file, "r") as f:
+            lyrics = f.read()
+
+    os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
+
+    result = generate_music(
+        prompt=args.prompt,
+        lyrics=lyrics,
+        model=args.model,
+        is_instrumental=args.instrumental,
+        lyrics_optimizer=args.auto_lyrics,
+        sample_rate=args.sample_rate,
+        bitrate=args.bitrate,
+        fmt=args.fmt,
+    )
+
+    if result["audio_bytes"]:
+        with open(args.output, "wb") as f:
+            f.write(result["audio_bytes"])
+        size = len(result["audio_bytes"])
+    else:
+        # URL mode — download
+        r = requests.get(result["audio_url"], timeout=120)
+        r.raise_for_status()
+        with open(args.output, "wb") as f:
+            f.write(r.content)
+        size = len(r.content)
+
+    duration = result.get("duration", "?")
+    print(f"OK: {size} bytes -> {args.output} (duration: {duration}s)")
+
+
+if __name__ == "__main__":
+    main()

package/skills/frontend-dev/scripts/minimax_tts.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+MiniMax Sync TTS (HTTP)
+Self-contained: no external dependencies beyond `requests`.
+
+Usage:
+  python minimax_tts.py "Hello world" -o output.mp3
+  python minimax_tts.py "你好世界" -o hi.mp3 -v female-shaonv --model speech-2.8-hd
+  python minimax_tts.py "Welcome" -o out.wav -v male-qn-jingying --speed 0.8 --format wav
+
+Env: MINIMAX_API_KEY (required)
+"""
+
+import os
+import sys
+import json
+import argparse
+import requests
+
+API_KEY = os.getenv("MINIMAX_API_KEY")
+# China Mainland: https://api.minimaxi.com/v1
+# Overseas:       https://api.minimax.io/v1
+API_BASE = os.getenv("MINIMAX_API_BASE")
+if not API_BASE:
+    raise SystemExit("ERROR: MINIMAX_API_BASE is not set.")
+
+
+def tts(
+    text: str,
+    voice_id: str = "male-qn-qingse",
+    model: str = "speech-2.8-hd",
+    speed: float = 1.0,
+    volume: float = 1.0,
+    pitch: int = 0,
+    emotion: str = "",
+    sample_rate: int = 32000,
+    bitrate: int = 128000,
+    fmt: str = "mp3",
+    language_boost: str = "auto",
+    timeout: int = 120,
+) -> bytes:
+    """Synchronous HTTP TTS. Returns raw audio bytes."""
+    if not API_KEY:
+        raise SystemExit("ERROR: MINIMAX_API_KEY is not set.\n  export MINIMAX_API_KEY='your-key'")
+
+    voice_setting = {"voice_id": voice_id, "speed": speed, "vol": volume, "pitch": pitch}
+    if emotion:
+        voice_setting["emotion"] = emotion
+
+    payload = {
+        "model": model,
+        "text": text,
+        "stream": False,
+        "voice_setting": voice_setting,
+        "audio_setting": {
+            "sample_rate": sample_rate,
+            "bitrate": bitrate,
+            "format": fmt,
+            "channel": 1,
+        },
+        "language_boost": language_boost,
+        "output_format": "hex",
+    }
+
+    resp = requests.post(
+        f"{API_BASE}/t2a_v2",
+        headers={
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json",
+        },
+        json=payload,
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    # Check API-level error
+    base_resp = data.get("base_resp", {})
+    if base_resp.get("status_code", 0) != 0:
+        raise SystemExit(f"API Error [{base_resp.get('status_code')}]: {base_resp.get('status_msg')}")
+
+    audio_hex = data.get("data", {}).get("audio", "")
+    if not audio_hex:
+        raise SystemExit(f"No audio in response: {json.dumps(data, indent=2)}")
+
+    return bytes.fromhex(audio_hex)
+
+
+def main():
+    p = argparse.ArgumentParser(description="MiniMax Sync TTS (HTTP)")
+    p.add_argument("text", help="Text to synthesize (max 10000 chars)")
+    p.add_argument("-o", "--output", required=True, help="Output file path")
+    p.add_argument("-v", "--voice", default="male-qn-qingse", help="Voice ID")
+    p.add_argument("--model", default="speech-2.8-hd", help="Model (default: speech-2.8-hd)")
+    p.add_argument("--speed", type=float, default=1.0, help="Speed 0.5-2.0")
+    p.add_argument("--volume", type=float, default=1.0, help="Volume 0.1-10")
+    p.add_argument("--pitch", type=int, default=0, help="Pitch -12 to 12")
+    p.add_argument("--emotion", default="", help="Emotion tag (happy/sad/angry/...)")
+    p.add_argument("--format", default="mp3", dest="fmt", help="Audio format (mp3/wav/flac)")
+    p.add_argument("--sample-rate", type=int, default=32000, help="Sample rate")
+    p.add_argument("--lang", default="auto", help="Language boost")
+    args = p.parse_args()
+
+    os.makedirs(os.path.dirname(args.output) or ".", exist_ok=True)
+
+    audio = tts(
+        text=args.text,
+        voice_id=args.voice,
+        model=args.model,
+        speed=args.speed,
+        volume=args.volume,
+        pitch=args.pitch,
+        emotion=args.emotion,
+        fmt=args.fmt,
+        sample_rate=args.sample_rate,
+        language_boost=args.lang,
+    )
+
+    with open(args.output, "wb") as f:
+        f.write(audio)
+
+    print(f"OK: {len(audio)} bytes -> {args.output}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/frontend-dev/scripts/minimax_video.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+MiniMax Text-to-Video — async generation with polling and download.
+
+Usage:
+  python minimax_video.py "A cat playing piano" -o cat.mp4
+  python minimax_video.py "Ocean waves [Truck left]" -o waves.mp4 --model MiniMax-Hailuo-2.3 --duration 10
+  python minimax_video.py "City skyline at sunset [Push in]" -o city.mp4 --resolution 1080P
+
+Env: MINIMAX_API_KEY (required)
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+import requests
+
+API_KEY = os.getenv("MINIMAX_API_KEY")
+# China Mainland: https://api.minimaxi.com/v1
+# Overseas:       https://api.minimax.io/v1
+API_BASE = os.getenv("MINIMAX_API_BASE")
+if not API_BASE:
+    raise SystemExit("ERROR: MINIMAX_API_BASE is not set.")
+
+
+def _headers():
+    if not API_KEY:
+        raise SystemExit("ERROR: MINIMAX_API_KEY is not set.\n  export MINIMAX_API_KEY='your-key'")
+    return {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json",
+    }
+
+
+def _check_resp(data):
+    base_resp = data.get("base_resp", {})
+    code = base_resp.get("status_code", 0)
+    if code != 0:
+        msg = base_resp.get("status_msg", "Unknown error")
+        raise SystemExit(f"API Error [{code}]: {msg}")
+
+
+def create_task(
+    prompt: str,
+    model: str = "MiniMax-Hailuo-2.3",
+    duration: int = 6,
+    resolution: str = "768P",
+    prompt_optimizer: bool = True,
+) -> str:
+    """Submit a video generation task. Returns task_id."""
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "duration": duration,
+        "resolution": resolution,
+        "prompt_optimizer": prompt_optimizer,
+    }
+
+    resp = requests.post(
+        f"{API_BASE}/video_generation",
+        headers=_headers(),
+        json=payload,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    _check_resp(data)
+
+    task_id = data.get("task_id")
+    if not task_id:
+        raise SystemExit(f"No task_id in response: {json.dumps(data, indent=2)}")
+    return task_id
+
+
+def poll_task(task_id: str, interval: int = 10, max_wait: int = 600) -> str:
+    """Poll task status until Success. Returns file_id."""
+    elapsed = 0
+    while elapsed < max_wait:
+        resp = requests.get(
+            f"{API_BASE}/query/video_generation",
+            headers=_headers(),
+            params={"task_id": task_id},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        _check_resp(data)
+
+        status = data.get("status", "")
+        file_id = data.get("file_id", "")
+
+        if status == "Success":
+            if not file_id:
+                raise SystemExit("Task succeeded but no file_id returned")
+            print(f"  Done! file_id={file_id}")
+            return file_id
+        elif status == "Fail":
+            raise SystemExit(f"Video generation failed: {json.dumps(data, indent=2)}")
+        else:
+            print(f"  [{elapsed}s] Status: {status}...")
+            time.sleep(interval)
+            elapsed += interval
+
+    raise SystemExit(f"Timeout after {max_wait}s. task_id={task_id}, check manually.")
+
+
+def download_video(file_id: str, output_path: str):
+    """Retrieve download URL via file_id and save the video."""
+    resp = requests.get(
+        f"{API_BASE}/files/retrieve",
+        headers=_headers(),
+        params={"file_id": file_id},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    _check_resp(data)
+
+    download_url = data.get("file", {}).get("download_url", "")
+    if not download_url:
+        raise SystemExit(f"No download_url in response: {json.dumps(data, indent=2)}")
+
+    print(f"  Downloading from {download_url[:80]}...")
+    video_resp = requests.get(download_url, timeout=300)
+    video_resp.raise_for_status()
+
+    os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
+    with open(output_path, "wb") as f:
+        f.write(video_resp.content)
+
+    print(f"OK: {len(video_resp.content)} bytes -> {output_path}")
+
+
+def generate(
+    prompt: str,
+    output_path: str,
+    model: str = "MiniMax-Hailuo-2.3",
+    duration: int = 6,
+    resolution: str = "768P",
+    prompt_optimizer: bool = True,
+    poll_interval: int = 10,
+    max_wait: int = 600,
+):
+    """Full pipeline: create task -> poll -> download."""
+    print(f"Creating video task...")
+    print(f"  Model: {model} | Duration: {duration}s | Resolution: {resolution}")
+    print(f"  Prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}")
+
+    task_id = create_task(prompt, model, duration, resolution, prompt_optimizer)
+    print(f"  task_id={task_id}")
+    print(f"Waiting for generation...")
+
+    file_id = poll_task(task_id, poll_interval, max_wait)
+    download_video(file_id, output_path)
+
+
+def main():
+    p = argparse.ArgumentParser(description="MiniMax Text-to-Video")
+    p.add_argument("prompt", help="Video description (max 2000 chars). Use [Camera Command] for camera control.")
+    p.add_argument("-o", "--output", required=True, help="Output file path (.mp4)")
+    p.add_argument("--model", default="MiniMax-Hailuo-2.3",
+                   choices=["MiniMax-Hailuo-2.3", "MiniMax-Hailuo-02", "T2V-01-Director", "T2V-01"],
+                   help="Model (default: MiniMax-Hailuo-2.3)")
+    p.add_argument("--duration", type=int, default=6, choices=[6, 10], help="Duration in seconds (default: 6)")
+    p.add_argument("--resolution", default="768P", choices=["720P", "768P", "1080P"], help="Resolution (default: 768P)")
+    p.add_argument("--no-optimize", action="store_true", help="Disable prompt auto-optimization")
+    p.add_argument("--poll-interval", type=int, default=10, help="Poll interval in seconds (default: 10)")
+    p.add_argument("--max-wait", type=int, default=600, help="Max wait time in seconds (default: 600)")
+    args = p.parse_args()
+
+    generate(
+        prompt=args.prompt,
+        output_path=args.output,
+        model=args.model,
+        duration=args.duration,
+        resolution=args.resolution,
+        prompt_optimizer=not args.no_optimize,
+        poll_interval=args.poll_interval,
+        max_wait=args.max_wait,
+    )
+
+
+if __name__ == "__main__":
+    main()

package/skills/frontend-dev/templates/generator_template.js

@@ -0,0 +1,223 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ *                  P5.JS GENERATIVE ART - BEST PRACTICES
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * This file shows STRUCTURE and PRINCIPLES for p5.js generative art.
+ * It does NOT prescribe what art you should create.
+ *
+ * Your algorithmic philosophy should guide what you build.
+ * These are just best practices for how to structure your code.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+// ============================================================================
+// 1. PARAMETER ORGANIZATION
+// ============================================================================
+// Keep all tunable parameters in one object
+// This makes it easy to:
+// - Connect to UI controls
+// - Reset to defaults
+// - Serialize/save configurations
+
+let params = {
+    // Define parameters that match YOUR algorithm
+    // Examples (customize for your art):
+    // - Counts: how many elements (particles, circles, branches, etc.)
+    // - Scales: size, speed, spacing
+    // - Probabilities: likelihood of events
+    // - Angles: rotation, direction
+    // - Colors: palette arrays
+
+    seed: 12345,
+    // define colorPalette as an array -- choose whatever colors you'd like ['#d97757', '#6a9bcc', '#788c5d', '#b0aea5']
+    // Add YOUR parameters here based on your algorithm
+};
+
+// ============================================================================
+// 2. SEEDED RANDOMNESS (Critical for reproducibility)
+// ============================================================================
+// ALWAYS use seeded random for Art Blocks-style reproducible output
+
+function initializeSeed(seed) {
+    randomSeed(seed);
+    noiseSeed(seed);
+    // Now all random() and noise() calls will be deterministic
+}
+
+// ============================================================================
+// 3. P5.JS LIFECYCLE
+// ============================================================================
+
+function setup() {
+    createCanvas(800, 800);
+
+    // Initialize seed first
+    initializeSeed(params.seed);
+
+    // Set up your generative system
+    // This is where you initialize:
+    // - Arrays of objects
+    // - Grid structures
+    // - Initial positions
+    // - Starting states
+
+    // For static art: call noLoop() at the end of setup
+    // For animated art: let draw() keep running
+}
+
+function draw() {
+    // Option 1: Static generation (runs once, then stops)
+    // - Generate everything in setup()
+    // - Call noLoop() in setup()
+    // - draw() doesn't do much or can be empty
+
+    // Option 2: Animated generation (continuous)
+    // - Update your system each frame
+    // - Common patterns: particle movement, growth, evolution
+    // - Can optionally call noLoop() after N frames
+
+    // Option 3: User-triggered regeneration
+    // - Use noLoop() by default
+    // - Call redraw() when parameters change
+}
+
+// ============================================================================
+// 4. CLASS STRUCTURE (When you need objects)
+// ============================================================================
+// Use classes when your algorithm involves multiple entities
+// Examples: particles, agents, cells, nodes, etc.
+
+class Entity {
+    constructor() {
+        // Initialize entity properties
+        // Use random() here - it will be seeded
+    }
+
+    update() {
+        // Update entity state
+        // This might involve:
+        // - Physics calculations
+        // - Behavioral rules
+        // - Interactions with neighbors
+    }
+
+    display() {
+        // Render the entity
+        // Keep rendering logic separate from update logic
+    }
+}
+
+// ============================================================================
+// 5. PERFORMANCE CONSIDERATIONS
+// ============================================================================
+
+// For large numbers of elements:
+// - Pre-calculate what you can
+// - Use simple collision detection (spatial hashing if needed)
+// - Limit expensive operations (sqrt, trig) when possible
+// - Consider using p5 vectors efficiently
+
+// For smooth animation:
+// - Aim for 60fps
+// - Profile if things are slow
+// - Consider reducing particle counts or simplifying calculations
+
+// ============================================================================
+// 6. UTILITY FUNCTIONS
+// ============================================================================
+
+// Color utilities
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16)
+    } : null;
+}
+
+function colorFromPalette(index) {
+    return params.colorPalette[index % params.colorPalette.length];
+}
+
+// Mapping and easing
+function mapRange(value, inMin, inMax, outMin, outMax) {
+    return outMin + (outMax - outMin) * ((value - inMin) / (inMax - inMin));
+}
+
+function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+
+// Constrain to bounds
+function wrapAround(value, max) {
+    if (value < 0) return max;
+    if (value > max) return 0;
+    return value;
+}
+
+// ============================================================================
+// 7. PARAMETER UPDATES (Connect to UI)
+// ============================================================================
+
+function updateParameter(paramName, value) {
+    params[paramName] = value;
+    // Decide if you need to regenerate or just update
+    // Some params can update in real-time, others need full regeneration
+}
+
+function regenerate() {
+    // Reinitialize your generative system
+    // Useful when parameters change significantly
+    initializeSeed(params.seed);
+    // Then regenerate your system
+}
+
+// ============================================================================
+// 8. COMMON P5.JS PATTERNS
+// ============================================================================
+
+// Drawing with transparency for trails/fading
+function fadeBackground(opacity) {
+    fill(250, 249, 245, opacity); // brand light with alpha
+    noStroke();
+    rect(0, 0, width, height);
+}
+
+// Using noise for organic variation
+function getNoiseValue(x, y, scale = 0.01) {
+    return noise(x * scale, y * scale);
+}
+
+// Creating vectors from angles
+function vectorFromAngle(angle, magnitude = 1) {
+    return createVector(cos(angle), sin(angle)).mult(magnitude);
+}
+
+// ============================================================================
+// 9. EXPORT FUNCTIONS
+// ============================================================================
+
+function exportImage() {
+    saveCanvas('generative-art-' + params.seed, 'png');
+}
+
+// ============================================================================
+// REMEMBER
+// ============================================================================
+//
+// These are TOOLS and PRINCIPLES, not a recipe.
+// Your algorithmic philosophy should guide WHAT you create.
+// This structure helps you create it WELL.
+//
+// Focus on:
+// - Clean, readable code
+// - Parameterized for exploration
+// - Seeded for reproducibility
+// - Performant execution
+//
+// The art itself is entirely up to you!
+//
+// ============================================================================