hyper-animator-codex 0.1.0 → 0.3.0

package/skills/hyper-animator-codex/scripts/generate_minimax_music.mjs

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  DEFAULT_MINIMAX_MODEL,
+  readMinimaxRuntimeConfig,
+  redactMinimaxConfig,
+  validateMinimaxConfig,
+} from "./minimax_runtime_config.mjs";
+
+const ENDPOINT = "https://api.minimaxi.com/v1/music_generation";
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const skillRoot = dirname(scriptDir);
+
+function requireValue(args, index, flag) {
+  const value = args[index + 1];
+
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value`);
+  }
+
+  return value;
+}
+
+function parseArgs(args) {
+  const parsed = {
+    prompt: undefined,
+    lyrics: undefined,
+    lyrics_optimizer: false,
+    is_instrumental: true,
+    output_dir: join(process.cwd(), "hyper-animator-output", "music"),
+    output_format: "hex",
+    audio_format: "mp3",
+    sample_rate: 44100,
+    bitrate: 256000,
+    model: undefined,
+    config_path: undefined,
+    dry_run: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--prompt") {
+      parsed.prompt = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--lyrics") {
+      parsed.lyrics = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--lyrics-optimizer") {
+      parsed.lyrics_optimizer = true;
+    } else if (arg === "--instrumental") {
+      parsed.is_instrumental = true;
+    } else if (arg === "--vocal") {
+      parsed.is_instrumental = false;
+    } else if (arg === "--output-dir") {
+      parsed.output_dir = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--output-format") {
+      parsed.output_format = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--format") {
+      parsed.audio_format = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--sample-rate") {
+      parsed.sample_rate = Number.parseInt(requireValue(args, index, arg), 10);
+      index += 1;
+    } else if (arg === "--bitrate") {
+      parsed.bitrate = Number.parseInt(requireValue(args, index, arg), 10);
+      index += 1;
+    } else if (arg === "--model") {
+      parsed.model = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--config") {
+      parsed.config_path = requireValue(args, index, arg);
+      index += 1;
+    } else if (arg === "--dry-run") {
+      parsed.dry_run = true;
+    } else if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`Usage:
+  node scripts/generate_minimax_music.mjs --prompt <text> [options]
+
+Options:
+  --prompt <text>              Music style, mood, and scene prompt
+  --lyrics <text>              Lyrics for vocal generation
+  --lyrics-optimizer           Let MiniMax generate lyrics from prompt for vocal generation
+  --instrumental               Generate instrumental music, default
+  --vocal                      Generate vocal music; requires --lyrics or --lyrics-optimizer
+  --output-dir <dir>           Directory for generated audio and metadata
+  --output-format <hex|url>    MiniMax response format, default hex
+  --format <mp3|wav|pcm>       Audio encoding format, default mp3
+  --sample-rate <rate>         16000, 24000, 32000, or 44100; default 44100
+  --bitrate <bits>             32000, 64000, 128000, or 256000; default 256000
+  --model <model>              music-2.6 or music-2.6-free
+  --config <file>              Explicit MiniMax config JSON
+  --dry-run                    Print redacted request without contacting MiniMax
+`);
+}
+
+function validateOptions(options) {
+  if (!options.prompt || options.prompt.trim().length === 0) {
+    throw new Error("--prompt is required");
+  }
+
+  if (options.prompt.length > 2000) {
+    throw new Error("--prompt must be 2000 characters or fewer");
+  }
+
+  if (!["hex", "url"].includes(options.output_format)) {
+    throw new Error("--output-format must be hex or url");
+  }
+
+  if (!["mp3", "wav", "pcm"].includes(options.audio_format)) {
+    throw new Error("--format must be mp3, wav, or pcm");
+  }
+
+  if (![16000, 24000, 32000, 44100].includes(options.sample_rate)) {
+    throw new Error("--sample-rate must be 16000, 24000, 32000, or 44100");
+  }
+
+  if (![32000, 64000, 128000, 256000].includes(options.bitrate)) {
+    throw new Error("--bitrate must be 32000, 64000, 128000, or 256000");
+  }
+
+  if (!options.is_instrumental && !options.lyrics && !options.lyrics_optimizer) {
+    throw new Error("Vocal MiniMax generation requires --lyrics or --lyrics-optimizer");
+  }
+
+  if (options.lyrics && options.lyrics.length > 3500) {
+    throw new Error("--lyrics must be 3500 characters or fewer");
+  }
+}
+
+function buildRequest(options, config) {
+  const model = options.model || config.model || DEFAULT_MINIMAX_MODEL;
+  const validatedConfig = validateMinimaxConfig({
+    ...config,
+    model,
+  });
+
+  const request = {
+    model: validatedConfig.model,
+    prompt: options.prompt,
+    stream: false,
+    output_format: options.output_format,
+    audio_setting: {
+      sample_rate: options.sample_rate,
+      bitrate: options.bitrate,
+      format: options.audio_format,
+    },
+    is_instrumental: options.is_instrumental,
+  };
+
+  if (options.lyrics) {
+    request.lyrics = options.lyrics;
+  }
+
+  if (options.lyrics_optimizer) {
+    request.lyrics_optimizer = true;
+  }
+
+  return request;
+}
+
+function safeFileStem(prompt) {
+  const stem = prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+
+  return stem || "minimax-music";
+}
+
+async function downloadUrl(url) {
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`MiniMax audio URL download failed with HTTP ${response.status}`);
+  }
+
+  return Buffer.from(await response.arrayBuffer());
+}
+
+function decodeHexAudio(value) {
+  if (!/^[0-9a-fA-F]+$/.test(value) || value.length % 2 !== 0) {
+    throw new Error("MiniMax response audio is not valid hex data");
+  }
+
+  return Buffer.from(value, "hex");
+}
+
+async function callMiniMax(config, request) {
+  const response = await fetch(ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.api_key}`,
+    },
+    body: JSON.stringify(request),
+  });
+
+  const text = await response.text();
+  let json;
+
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`MiniMax returned non-JSON response with HTTP ${response.status}`);
+  }
+
+  if (!response.ok) {
+    const message = json.base_resp?.status_msg || `HTTP ${response.status}`;
+    throw new Error(`MiniMax request failed: ${message}`);
+  }
+
+  const statusCode = json.base_resp?.status_code;
+  if (statusCode !== 0) {
+    const message = json.base_resp?.status_msg || "unknown MiniMax error";
+    throw new Error(`MiniMax request failed with status_code ${statusCode}: ${message}`);
+  }
+
+  if (json.data?.status !== 2) {
+    throw new Error(`MiniMax generation is not complete; data.status is ${json.data?.status}`);
+  }
+
+  if (!json.data?.audio) {
+    throw new Error("MiniMax response did not include data.audio");
+  }
+
+  return json;
+}
+
+async function writeAudioOutput({ responseJson, request, outputDir, prompt }) {
+  await mkdir(outputDir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const stem = `${safeFileStem(prompt)}-${timestamp}`;
+  const extension = request.audio_setting.format === "pcm" ? "pcm" : request.audio_setting.format;
+  const audioPath = join(outputDir, `${stem}.${extension}`);
+  const metadataPath = join(outputDir, `${stem}.minimax.json`);
+  const audioValue = responseJson.data.audio;
+  const audioBuffer = request.output_format === "url"
+    ? await downloadUrl(audioValue)
+    : decodeHexAudio(audioValue);
+
+  await writeFile(audioPath, audioBuffer);
+  await writeFile(
+    metadataPath,
+    `${JSON.stringify({
+      provider: "minimax",
+      endpoint: ENDPOINT,
+      request,
+      response: {
+        base_resp: responseJson.base_resp,
+        data: {
+          status: responseJson.data.status,
+        },
+        extra_info: responseJson.extra_info,
+        trace_id: responseJson.trace_id,
+      },
+      audio_path: audioPath,
+    }, null, 2)}\n`,
+    "utf8",
+  );
+
+  return {
+    audioPath,
+    metadataPath,
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  validateOptions(options);
+
+  const runtime = await readMinimaxRuntimeConfig({
+    skillRoot,
+    env: process.env,
+    configPath: options.config_path,
+  });
+
+  if (!runtime) {
+    throw new Error("MiniMax config not found. Run hyper-animator-codex install with --minimax-api-key and --minimax-group-id, or set MINIMAX_API_KEY and MINIMAX_GROUP_ID.");
+  }
+
+  const request = buildRequest(options, runtime.config);
+  const redactedConfig = redactMinimaxConfig(runtime.config);
+
+  if (options.dry_run) {
+    console.log(JSON.stringify({
+      ok: true,
+      dry_run: true,
+      provider: "minimax",
+      endpoint: ENDPOINT,
+      config: {
+        source: runtime.source,
+        path: runtime.configPath,
+        redacted: redactedConfig,
+      },
+      request,
+      output_dir: options.output_dir,
+    }, null, 2));
+    return;
+  }
+
+  const responseJson = await callMiniMax(runtime.config, request);
+  const output = await writeAudioOutput({
+    responseJson,
+    request,
+    outputDir: options.output_dir,
+    prompt: options.prompt,
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    provider: "minimax",
+    model: request.model,
+    output_path: output.audioPath,
+    metadata_path: output.metadataPath,
+    beat_analysis_command: `python3 scripts/analyze_music_beats.py ${output.audioPath} -o ${join(options.output_dir, "beat-map.json")} --fps 60 --pretty`,
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+});

package/skills/hyper-animator-codex/scripts/minimax_runtime_config.mjs

@@ -0,0 +1,113 @@
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+export const DEFAULT_MINIMAX_MODEL = "music-2.6-free";
+export const TEXT_MUSIC_MODELS = new Set(["music-2.6", "music-2.6-free"]);
+
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function cleanString(value) {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function normalize(input = {}) {
+  return {
+    api_key: cleanString(input.api_key),
+    group_id: cleanString(input.group_id),
+    model: cleanString(input.model),
+  };
+}
+
+function hasValues(input = {}) {
+  return Boolean(cleanString(input.api_key) || cleanString(input.group_id) || cleanString(input.model));
+}
+
+export function redactMinimaxConfig(config = {}) {
+  const normalized = normalize(config);
+
+  return {
+    api_key: normalized.api_key ? "[redacted]" : undefined,
+    group_id: normalized.group_id,
+    model: normalized.model || DEFAULT_MINIMAX_MODEL,
+  };
+}
+
+export function validateMinimaxConfig(config = {}) {
+  const normalized = normalize(config);
+
+  if (!normalized.api_key) {
+    throw new Error("MiniMax api_key is required");
+  }
+
+  if (!normalized.group_id) {
+    throw new Error("MiniMax group_id is required");
+  }
+
+  const model = normalized.model || DEFAULT_MINIMAX_MODEL;
+
+  if (!TEXT_MUSIC_MODELS.has(model)) {
+    throw new Error(`Unsupported MiniMax text music model: ${model}. Use music-2.6 or music-2.6-free.`);
+  }
+
+  return {
+    api_key: normalized.api_key,
+    group_id: normalized.group_id,
+    model,
+  };
+}
+
+async function readJson(path) {
+  const raw = await readFile(path, "utf8");
+  const parsed = JSON.parse(raw);
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`MiniMax config file must be a JSON object: ${path}`);
+  }
+
+  return parsed;
+}
+
+export async function readMinimaxRuntimeConfig({ skillRoot, env = process.env, configPath } = {}) {
+  const explicitConfigPath = cleanString(configPath);
+  const defaultConfigPath = skillRoot ? join(skillRoot, "config", "minimax.json") : undefined;
+  const filePath = explicitConfigPath || defaultConfigPath;
+
+  if (filePath && await pathExists(filePath)) {
+    return {
+      source: "file",
+      configPath: filePath,
+      config: validateMinimaxConfig(await readJson(filePath)),
+    };
+  }
+
+  const envConfig = normalize({
+    api_key: env.MINIMAX_API_KEY,
+    group_id: env.MINIMAX_GROUP_ID,
+    model: env.MINIMAX_MODEL,
+  });
+
+  if (!hasValues(envConfig)) {
+    return null;
+  }
+
+  return {
+    source: "environment",
+    configPath: null,
+    config: validateMinimaxConfig(envConfig),
+  };
+}

package/skills/hyper-animator-codex/vendor/music-beat-detector/README.md

@@ -0,0 +1,13 @@
+# Vendored music-beat-detector
+
+Trimmed source from `git@github.com:realpkuasule/music-beat-detector.git`, commit `29b081fbe3bb38f0fa8cb569fa3150d7cfdb18cb`.
+
+Only `beat_detector/` is vendored. Sample media, ffmpeg archives, development contracts, and upstream tests are intentionally omitted from the npm package.
+
+Optional runtime dependencies:
+
+```bash
+python3 -m pip install librosa pydub numpy click
+```
+
+MP3/M4A/AAC/WMA files require system `ffmpeg`; WAV/FLAC/OGG are preferred for fewer dependencies.

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/__init__.py

@@ -0,0 +1,33 @@
+"""Music Beat Detector - 音乐自动打点工具"""
+
+from .analyzer import analyze, AnalysisResult, MetaInfo
+from .beat import Beat, BeatResult, EnergyLevel
+from .structure import Segment, EnergyPeak, SilenceRegion, StructureResult
+from .errors import BeatDetectorError, FileNotFoundError, UnsupportedFormatError, AnalysisError, FFmpegRequiredError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # 主要 API
+    'analyze',
+    'AnalysisResult',
+    'MetaInfo',
+
+    # 节拍检测
+    'Beat',
+    'BeatResult',
+    'EnergyLevel',
+
+    # 结构检测
+    'StructureResult',
+    'Segment',
+    'EnergyPeak',
+    'SilenceRegion',
+
+    # 异常
+    'BeatDetectorError',
+    'FileNotFoundError',
+    'UnsupportedFormatError',
+    'FFmpegRequiredError',
+    'AnalysisError',
+]

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/analyzer.py

@@ -0,0 +1,129 @@
+"""分析器模块"""
+from dataclasses import dataclass, field, asdict
+from typing import List, Callable, Optional, Any
+import json
+import logging
+import numpy as np
+
+from .beat import Beat, BeatResult, detect_beats
+from .structure import StructureResult, detect_structure
+from .utils import load_audio, setup_logging
+from .errors import (
+    FileNotFoundError as BeatDetectorFileNotFoundError,
+    FFmpegRequiredError,
+    UnsupportedFormatError
+)
+
+
+@dataclass
+class MetaInfo:
+    """元信息"""
+    file: str
+    duration_ms: int
+    sample_rate: int
+    bpm: float
+    time_signature: str = "4/4"
+
+
+@dataclass
+class AnalysisResult:
+    """完整分析结果"""
+    meta: MetaInfo
+    beats: List[Beat] = field(default_factory=list)
+    structure: Optional[StructureResult] = None
+
+    def to_dict(self) -> dict:
+        """转换为字典"""
+        result = {
+            'meta': asdict(self.meta),
+            'beats': [
+                {
+                    'time_ms': beat.time_ms,
+                    'frame': beat.frame,
+                    'beat_in_bar': beat.beat_in_bar,
+                    'energy_level': beat.energy_level.value
+                }
+                for beat in self.beats
+            ],
+            'structure': {
+                'segments': [asdict(seg) for seg in self.structure.segments],
+                'energy_peaks': [asdict(peak) for peak in self.structure.energy_peaks],
+                'silence_regions': [asdict(region) for region in self.structure.silence_regions],
+            }
+        }
+        return result
+
+    def to_json(self, pretty: bool = False) -> str:
+        """导出为 JSON"""
+        indent = 2 if pretty else None
+        return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)
+
+    def save(self, path: str, pretty: bool = False) -> None:
+        """保存到文件"""
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(self.to_json(pretty=pretty))
+
+
+def analyze(
+    file_path: str,
+    fps: int = 30,
+    log_level: str = "info",
+    on_progress: Optional[Callable[[float], None]] = None
+) -> AnalysisResult:
+    """分析音频文件"""
+
+    # 设置日志
+    setup_logging(log_level)
+    logger = logging.getLogger(__name__)
+
+    # 进度辅助函数
+    def report_progress(stage_progress: float):
+        if on_progress:
+            on_progress(stage_progress)
+
+    # 加载音频
+    logger.info(f"Loading audio file: {file_path}")
+    try:
+        y, sr = load_audio(file_path)
+    except (BeatDetectorFileNotFoundError, FFmpegRequiredError, UnsupportedFormatError):
+        raise
+    except Exception as e:
+        raise BeatDetectorFileNotFoundError(file_path)
+
+    report_progress(10.0)
+
+    # 计算时长
+    duration_ms = int(len(y) / sr * 1000)
+    logger.info(f"Audio duration: {duration_ms/1000:.1f}s, sample rate: {sr}Hz")
+
+    # 节拍检测
+    logger.info("Detecting beats...")
+    beat_result = detect_beats(y, sr, fps=fps, on_progress=lambda p: report_progress(10 + p * 0.45))
+    logger.info(f"Detected BPM: {beat_result.bpm:.1f}")
+
+    report_progress(55.0)
+
+    # 结构检测
+    logger.info("Analyzing structure...")
+    structure_result = detect_structure(y, sr, fps=fps, on_progress=lambda p: report_progress(55 + p * 0.45))
+    logger.info(f"Found {len(structure_result.segments)} segments")
+
+    report_progress(100.0)
+
+    # 构建结果
+    meta = MetaInfo(
+        file=file_path,
+        duration_ms=duration_ms,
+        sample_rate=sr,
+        bpm=beat_result.bpm,
+        time_signature=beat_result.time_signature
+    )
+
+    result = AnalysisResult(
+        meta=meta,
+        beats=beat_result.beats,
+        structure=structure_result
+    )
+
+    logger.info("Analysis complete")
+    return result