skill-mv/scripts/pipeline-a.mjs

// scripts/pipeline-a.mjs — 产线A 编排：AI 单曲 MV 端到端
//
// 主题 → 作曲填词 → AI 音乐 → 人声/伴奏分离 → 关键帧 → 图生视频 → 唇形 → 剪辑成片
//
// 编排原则：
//   · 每一步都能单独跑（对应 fmode-mv <step>），pipeline 只是串起来；
//   · 通道不可用的步骤「如实跳过并记录原因」，能兜底的就兜底（视频→Ken Burns）；
//   · 最后打印一张「步骤执行表」，一眼看清哪些是真产物、哪些是兜底/跳过。

import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
import { join } from 'node:path';
import {
  parseArgs, readJSON, writeJSON, paths, ensureWork, log, humanSize,
} from '../lib/index.mjs';
import { buildLyrics } from './lyrics.mjs';
import { buildStoryboardFromSong, renderStoryboardMd } from './storyboard.mjs';
import { generateKeyframes } from './keyframe.mjs';
import { generateClips } from './video.mjs';
import { assemble } from './assemble.mjs';
import { getProvider } from '../lib/providers.mjs';
import { probe as ffprobe, listMedia } from '../lib/ffmpeg.mjs';

export async function runPipelineA(theme, opts = {}) {
  const {
    title = '',
    genre = '',
    mood = '',
    limit = 0,
    aspect = '16:9',
    shots = 8,
    perShot = 6,
    outFile = join(paths.out, 'mv.mp4'),
    music = '',
    skipMusic = false,
    skipVideo = false,
    dryRun = false,
  } = opts;

  ensureWork();
  const steps = [];
  const mark = (name, status, detail) => {
    steps.push({ name, status, detail });
    return status;
  };

  // ---------- 1. 作曲填词 ----------
  log.step('[1/8] 作曲填词');
  let song;
  if (existsSync(paths.song) && opts.resume !== false) {
    song = readJSON(paths.song);
    mark('作曲填词', 'reused', `沿用 work/song.json《${song.title}》`);
    log.ok(`沿用已有：《${song.title}》`);
  } else {
    song = await buildLyrics(theme, { genre, mood });
    writeJSON(paths.song, song);
    mark('作曲填词', 'ok', `《${song.title}》`);
    log.ok(`《${song.title}》（${song.genre || '-'} / ${song.bpm || '?'}BPM）`);
  }

  // ---------- 2. 分镜 ----------
  log.step('[2/8] 分镜脚本');
  const sb = await buildStoryboardFromSong(song, { shotCount: shots, aspect, perShot });
  writeJSON(paths.storyboard, sb);
  writeFileSync(join(paths.work, 'storyboard.md'), renderStoryboardMd(sb), 'utf8');
  mark('分镜脚本', 'ok', `${sb.shots.length} 镜 / ${sb.totalDuration}s`);
  log.ok(`${sb.shots.length} 个镜头，总时长 ${sb.totalDuration}s`);

  // ---------- 3. AI 音乐 ----------
  log.step('[3/8] AI 音乐生成');
  let musicFile = music && existsSync(music) ? music : null;
  if (musicFile) {
    mark('AI 音乐', 'provided', `使用外部提供：${musicFile}`);
    log.ok(`使用指定音乐：${musicFile}`);
  } else if (skipMusic) {
    mark('AI 音乐', 'skipped', '--skip-music');
    log.warn('按参数跳过');
  } else {
    const p = getProvider('music');
    const pr = await p.probe({ deep: false });
    if (pr.available === false) {
      mark('AI 音乐', 'unavailable', pr.detail.split('\n')[0]);
      log.warn(`通道未开通，跳过：${pr.detail}`);
      log.dim('替代：--music <你的音频文件> / 等平台开通后重跑 / 自建兼容端点');
    } else {
      try {
        const { generateMusic } = await import('./music.mjs');
        const r = await generateMusic({ prompt: song.stylePrompt, lyrics: song.lyrics, title: song.title });
        musicFile = r.files[0].path;
        mark('AI 音乐', 'ok', musicFile);
        log.ok(musicFile);
      } catch (e) {
        mark('AI 音乐', 'failed', e.message.split('\n')[0]);
        log.err(`失败：${e.message.split('\n')[0]}`);
      }
    }
  }

  // ---------- 4. 音轨分离 ----------
  log.step('[4/8] 人声 / 伴奏分离');
  if (musicFile) {
    try {
      const { separate } = await import('./separate.mjs');
      const r = await separate(musicFile, { mode: 'both' });
      mark('音轨分离', 'ok', r.method === 'demucs' ? 'demucs（高质量）' : 'ffmpeg 相位兜底（近似）');
      log.ok(`方式：${r.method}`);
    } catch (e) {
      mark('音轨分离', 'failed', e.message.split('\n')[0]);
      log.err(`失败：${e.message.split('\n')[0]}`);
    }
  } else {
    mark('音轨分离', 'skipped', '无音乐文件');
    log.warn('无音乐文件，跳过');
  }

  // ---------- 5. 关键帧 ----------
  log.step('[5/8] 场景 & 人物关键帧');
  const kfJobs = limit ? sb.shots.slice(0, limit) : sb.shots;
  const sbLimited = { ...sb, shots: kfJobs };
  const kf = await generateKeyframes({ storyboard: sbLimited, outDir: paths.frames, aspect });
  mark('关键帧', kf.failCount ? 'partial' : 'ok', `成功 ${kf.okCount} / 失败 ${kf.failCount}`);
  log.ok(`成功 ${kf.okCount} 张，失败 ${kf.failCount} 张 → ${paths.frames}`);

  // ---------- 6. 图生视频 ----------
  log.step('[6/8] 图生视频');
  let clipResult = { results: [], mode: 'skipped' };
  if (skipVideo) {
    mark('图生视频', 'skipped', '--skip-video');
    log.warn('按参数跳过');
  } else {
    clipResult = await generateClips({ storyboard: sbLimited, mode: 'auto' });
    const ok = clipResult.results.filter((x) => x.status === 'ok').length;
    mark(
      '图生视频',
      clipResult.mode === 'provider' ? 'ok' : 'fallback',
      `${clipResult.mode === 'provider' ? '真通道' : 'Ken Burns 兜底'}：${ok} 段`
    );
    log.ok(`${clipResult.mode === 'provider' ? '真通道' : '兜底'}：${ok} 段`);
  }

  // ---------- 7. 唇形驱动 ----------
  log.step('[7/8] 唇形驱动');
  const lipShots = sbLimited.shots.filter((s) => s.lipSync);
  if (!lipShots.length) {
    mark('唇形驱动', 'n/a', '分镜中无 lipSync:true 镜头');
    log.dim('分镜里没有标记唇形的镜头，跳过');
  } else {
    const p = getProvider('lipsync');
    const pr = await p.probe({});
    if (!pr.available) {
      mark('唇形驱动', 'unavailable', `${lipShots.length} 个待处理镜头未处理`);
      log.warn(`通道不可用，${lipShots.length} 个唇形镜头未处理：${pr.detail}`);
      log.dim('替代：自建 Wav2Lip/SadTalker 并设 FEME_LIPSYNC_ENDPOINT；或改用表情微动镜头');
    } else {
      try {
        const { driveLip } = await import('./lipsync.mjs');
        let n = 0;
        for (const s of lipShots) {
          const face = join(paths.frames, `shot-${String(s.id).padStart(2, '0')}.png`);
          const audio = (musicFile && join(paths.audio, 'vocals.wav')) || join(paths.audio, 'vocals.wav');
          if (!existsSync(face) || !existsSync(audio)) continue;
          await driveLip(s, { faceImage: face, audio });
          n++;
        }
        mark('唇形驱动', 'ok', `${n} 个镜头`);
        log.ok(`${n} 个镜头完成`);
      } catch (e) {
        mark('唇形驱动', 'failed', e.message.split('\n')[0]);
        log.err(`失败：${e.message.split('\n')[0]}`);
      }
    }
  }

  // ---------- 8. 剪辑合成 ----------
  log.step('[8/8] 剪辑合成');
  let final = null;
  try {
    const r = await assemble({
      storyboard: sbLimited,
      clipsDir: paths.clips,
      outFile,
      music: musicFile || undefined,
      beatSync: true,
    });
    final = r.outFile;
    mark('剪辑合成', 'ok', `${r.info.duration.toFixed(1)}s / ${humanSize(r.info.size)}`);
  } catch (e) {
    mark('剪辑合成', 'failed', e.message.split('\n')[0]);
    log.err(`失败：${e.message.split('\n')[0]}`);
  }

  // ---------- 汇总 ----------
  const report = {
    pipeline: 'A',
    theme,
    title: song.title,
    aspect,
    shots: sb.shots.length,
    final,
    steps,
    generatedAt: new Date().toISOString(),
  };
  writeJSON(join(paths.work, 'pipeline-a.run.json'), report);
  printReport('产线A · AI 单曲 MV', report, { song, final });
  return report;
}

export function printReport(name, report, extra = {}) {
  console.log('');
  console.log('═'.repeat(64));
  console.log(`  ${name} · 执行报告`);
  console.log('═'.repeat(64));
  const icon = { ok: '✅', reused: '♻️ ', provided: '📎', fallback: '◐ ', partial: '◐ ', skipped: '⏭️ ', unavailable: '⚠️ ', failed: '❌', 'n/a': '· ' };
  const w = Math.max(...report.steps.map((s) => s.name.length));
  for (const s of report.steps) {
    console.log(`  ${icon[s.status] || '  '} ${s.name.padEnd(w)}  ${s.detail || ''}`);
  }
  console.log('─'.repeat(64));
  if (report.final) {
    console.log(`  成片: ${report.final}`);
  } else {
    console.log('  ⚠️  未产出成片（见上方失败/跳过项）');
  }
  console.log('');
  const bad = report.steps.filter((s) => s.status === 'failed' || s.status === 'unavailable');
  if (bad.length) {
    console.log('  未完成项:');
    for (const b of bad) console.log(`   · ${b.name}: ${b.detail}`);
    console.log('  详见 SKILL.md「能力现状」与 references/capability-matrix.md');
  }
  console.log('═'.repeat(64));
  console.log('');
}

export async function main(argv = process.argv.slice(2)) {
  const { _, flags } = parseArgs(argv);
  const theme = _.join(' ').trim();

  if (flags.help || !theme) {
    console.log(`
fmode-mv song — 产线A：AI 单曲 MV 端到端编排

用法:
  fmode-mv song "主题描述" [选项]

流程:
  作曲填词 → 分镜 → AI音乐 → 音轨分离 → 关键帧 → 图生视频 → 唇形 → 剪辑成片

选项:
  --title "歌名"     指定歌名（否则模型自定）
  --genre "曲风"     --mood "情绪"
  --shots <n>        镜头数（默认 8）
  --per-shot <s>     单镜秒数（默认 6）
  --limit <n>        只处理前 n 镜（试跑省钱）
  --aspect 16:9|9:16|1:1
  --music <file>     用自己已有的音乐（跳过 AI 音乐步骤）
  --skip-music       跳过音乐步骤
  --skip-video       跳过视频生成
  --out <file>       成片输出（默认 out/mv.mp4）
  --fresh            忽略已有 work/song.json，重新作曲填词

示例:
  fmode-mv song "深夜末班地铁上的城市白领" --genre "city pop" --limit 3
  fmode-mv song "..." --music my-song.mp3

⚠️ 通道现状（fmode-mv providers 可查）：
   ✅ chat / image / ffmpeg 可用；⚠️ music / video / lipsync 平台未开通。
   未开通的步骤会如实跳过或降级兜底，并在报告中标出，绝不伪造产物。
`);
    return 0;
  }

  await runPipelineA(theme, {
    title: flags.title || '',
    genre: flags.genre || '',
    mood: flags.mood || '',
    limit: Number(flags.limit) || 0,
    aspect: flags.aspect || '16:9',
    shots: Number(flags.shots) || 8,
    perShot: Number(flags['per-shot']) || 6,
    outFile: String(flags.out || join(paths.out, 'mv.mp4')),
    music: typeof flags.music === 'string' ? flags.music : '',
    skipMusic: !!flags['skip-music'],
    skipVideo: !!flags['skip-video'],
    resume: !flags.fresh,
  });
  return 0;
}

if (import.meta.url === `file://${process.argv[1]}`) {
  main().then((c) => process.exit(Number(c) || 0)).catch((e) => {
    console.error(`✗ ${e.message}`);
    if (process.env.DEBUG) console.error(e.stack);
    process.exit(1);
  });
}