Srt Remotion Video

#!/usr/bin/env node

/**
 * 模板依赖预检脚本
 *
 * 用法:
 *   node ensure-template-deps.js <templateRoot>
 *
 * 功能:
 *   - 检查 template/package.json 和 package-lock.json 是否存在
 *   - 检查模板关键依赖是否已安装
 *   - 若未安装，则在 templateRoot 下执行 npm install
 */

const fs = require('fs');
const path = require('path');
const {spawnSync} = require('child_process');

const REQUIRED_PACKAGES = [
  'remotion',
  'react',
  'react-dom',
  '@remotion/cli',
  'lucide-react',
];

function fail(stage, error, extra = {}) {
  console.error(JSON.stringify({
    success: false,
    stage,
    error,
    ...extra,
  }, null, 2));
  process.exit(1);
}

function ensureTemplateFiles(templateRoot) {
  const packageJsonPath = path.join(templateRoot, 'package.json');
  const packageLockPath = path.join(templateRoot, 'package-lock.json');

  if (!fs.existsSync(templateRoot)) {
    fail('precheck', `template 目录不存在: ${templateRoot}`);
  }

  if (!fs.existsSync(packageJsonPath)) {
    fail('precheck', `缺少 package.json: ${packageJsonPath}`);
  }

  if (!fs.existsSync(packageLockPath)) {
    fail('precheck', `缺少 package-lock.json: ${packageLockPath}`);
  }
}

function canResolvePackage(templateRoot, packageName) {
  try {
    require.resolve(`${packageName}/package.json`, {paths: [templateRoot]});
    return true;
  } catch (error) {
    return false;
  }
}

function getMissingPackages(templateRoot) {
  const nodeModulesPath = path.join(templateRoot, 'node_modules');
  if (!fs.existsSync(nodeModulesPath)) {
    return [...REQUIRED_PACKAGES];
  }

  return REQUIRED_PACKAGES.filter((packageName) => !canResolvePackage(templateRoot, packageName));
}

function getNpmCommand() {
  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
}

function runNpmInstall(templateRoot) {
  const npmCommand = getNpmCommand();
  const probe = spawnSync(npmCommand, ['--version'], {
    cwd: templateRoot,
    encoding: 'utf-8',
  });

  if (probe.error) {
    fail('precheck', `无法执行 npm: ${probe.error.message}`);
  }

  if (probe.status !== 0) {
    fail('precheck', 'npm 不可用，无法安装模板依赖', {
      stderr: (probe.stderr || '').trim(),
    });
  }

  console.error(`模板依赖缺失，正在安装: ${templateRoot}`);
  const install = spawnSync(npmCommand, ['install'], {
    cwd: templateRoot,
    encoding: 'utf-8',
    stdio: 'pipe',
  });

  if (install.error) {
    fail('install', `npm install 执行失败: ${install.error.message}`);
  }

  if (install.status !== 0) {
    fail('install', 'npm install 失败', {
      stdout: (install.stdout || '').trim().slice(-4000),
      stderr: (install.stderr || '').trim().slice(-4000),
    });
  }
}

function main() {
  const [templateRootArg] = process.argv.slice(2);
  if (!templateRootArg) {
    console.error('用法: node ensure-template-deps.js <templateRoot>');
    process.exit(1);
  }

  const templateRoot = path.resolve(templateRootArg);
  ensureTemplateFiles(templateRoot);

  const missingBeforeInstall = getMissingPackages(templateRoot);
  const alreadyInstalled = missingBeforeInstall.length === 0;

  if (!alreadyInstalled) {
    console.error(`检测到模板依赖缺失: ${missingBeforeInstall.join(', ')}`);
    runNpmInstall(templateRoot);
  } else {
    console.error('模板依赖已就绪，跳过安装');
  }

  const missingAfterInstall = getMissingPackages(templateRoot);
  if (missingAfterInstall.length > 0) {
    fail('verify', `模板依赖安装后仍缺失: ${missingAfterInstall.join(', ')}`, {
      missingPackages: missingAfterInstall,
    });
  }

  console.log(JSON.stringify({
    success: true,
    templateRoot,
    alreadyInstalled,
    installedWith: 'npm',
  }, null, 2));
}

main();

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

function fail(error, extra = {}) {
  console.error(JSON.stringify({
    success: false,
    error,
    ...extra,
  }, null, 2));
  process.exit(1);
}

function parseCreatorNumber(creatorId) {
  const match = /^creator-(\d+)$/.exec(String(creatorId).trim());
  if (!match) {
    fail(`creatorId 格式无效: ${creatorId}`);
  }

  const numericId = Number(match[1]);
  if (!Number.isInteger(numericId) || numericId <= 0) {
    fail(`creatorId 序号无效: ${creatorId}`);
  }

  return numericId;
}

function loadStoryboard(storyboardPath) {
  if (!fs.existsSync(storyboardPath)) {
    fail(`storyboard.json 不存在: ${storyboardPath}`);
  }

  const storyboard = JSON.parse(fs.readFileSync(storyboardPath, 'utf-8'));
  if (!storyboard || !Array.isArray(storyboard.scenes)) {
    fail(`storyboard.json 结构无效: ${storyboardPath}`);
  }

  return storyboard;
}

function ensureOutputDir(outputPath) {
  const outputDir = path.dirname(outputPath);
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, {recursive: true});
  }
}

function main() {
  const [storyboardPathArg, creatorId, scenesPerCreatorArg, outputPathArg] = process.argv.slice(2);

  if (!storyboardPathArg || !creatorId || !scenesPerCreatorArg || !outputPathArg) {
    console.error('用法: node generate-creator-scenes.js <storyboardPath> <creatorId> <scenesPerCreator> <outputPath>');
    process.exit(1);
  }

  const storyboardPath = path.resolve(storyboardPathArg);
  const outputPath = path.resolve(outputPathArg);
  const scenesPerCreator = Number(scenesPerCreatorArg);

  if (!Number.isInteger(scenesPerCreator) || scenesPerCreator <= 0) {
    fail(`scenesPerCreator 无效: ${scenesPerCreatorArg}`);
  }

  const creatorNumber = parseCreatorNumber(creatorId);
  const storyboard = loadStoryboard(storyboardPath);

  const startIndex = (creatorNumber - 1) * scenesPerCreator;
  const endIndexExclusive = startIndex + scenesPerCreator;
  const scenesData = storyboard.scenes.slice(startIndex, endIndexExclusive);

  if (scenesData.length === 0) {
    fail(`creator ${creatorId} 没有可分配的 scenes`, {
      creatorId,
      sceneCount: storyboard.scenes.length,
      scenesPerCreator,
    });
  }

  ensureOutputDir(outputPath);
  fs.writeFileSync(outputPath, JSON.stringify(scenesData, null, 2), 'utf-8');

  console.log(JSON.stringify({
    success: true,
    creatorId,
    storyboardPath,
    outputPath,
    scenesPerCreator,
    sceneIds: scenesData.map((scene) => scene.id),
  }, null, 2));
}

main();

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

const {
  buildGeneratedScenesSource,
  getActiveVideoProfile,
  loadStoryboard,
  loadVideoSettings,
  validateSceneComponentExports,
  validateSceneFilesAgainstStoryboard,
  validateSceneTimingAgainstStoryboard,
  validateStoryboardStructure,
} = require('./scene-registry-utils');

function main() {
  const args = process.argv.slice(2);
  if (args.length < 2 || args.length > 3) {
    console.error('用法: node generate-scenes-registry.js <projectRoot> <storyboardPath> [outputPath]');
    process.exit(1);
  }

  const [projectRoot, storyboardPath, outputPathArg] = args;
  const outputPath = outputPathArg || path.join(projectRoot, 'src', 'compositions', 'generated-scenes.ts');

  try {
    const storyboard = loadStoryboard(storyboardPath);
    const storyboardValidation = validateStoryboardStructure(storyboard);
    if (!storyboardValidation.valid) {
      console.error('❌ storyboard 校验失败:');
      storyboardValidation.errors.forEach((error) => console.error(`   - ${error}`));
      process.exit(1);
    }

    const fileValidation = validateSceneFilesAgainstStoryboard(projectRoot, storyboard);
    if (!fileValidation.valid) {
      console.error('❌ 场景文件校验失败:');
      fileValidation.errors.forEach((error) => console.error(`   - ${error}`));
      process.exit(1);
    }

    const exportValidation = validateSceneComponentExports(projectRoot, storyboard);
    if (!exportValidation.valid) {
      console.error('❌ 场景导出校验失败:');
      exportValidation.errors.forEach((error) => console.error(`   - ${error}`));
      process.exit(1);
    }

    const timingValidation = validateSceneTimingAgainstStoryboard(projectRoot, storyboard);
    if (!timingValidation.valid) {
      console.error('❌ 场景时序校验失败:');
      timingValidation.errors.forEach((error) => console.error(`   - ${error}`));
      process.exit(1);
    }

    if (timingValidation.warnings.length > 0) {
      console.warn('⚠️ 场景时序告警:');
      timingValidation.warnings.forEach((warning) => console.warn(`   - ${warning}`));
    }

    const videoSettings = loadVideoSettings(projectRoot);
    const activeProfile = getActiveVideoProfile(videoSettings);
    const source = buildGeneratedScenesSource(storyboard, { videoSettings });
    fs.writeFileSync(outputPath, source, 'utf-8');

    console.log('✅ generated-scenes.ts 已生成');
    console.log(`   - 输出文件: ${outputPath}`);
    console.log(`   - 场景数量: ${storyboard.sceneCount}`);
    console.log(`   - 输出规格: ${activeProfile.width}x${activeProfile.height} / ${activeProfile.fps}fps (${activeProfile.name})`);
    console.log('');
    console.log('__RESULT_JSON__');
    console.log(JSON.stringify({
      success: true,
      outputPath,
      sceneCount: storyboard.sceneCount,
      videoProfile: activeProfile,
    }));
  } catch (error) {
    console.error(`❌ 错误: ${error.message}`);
    process.exit(1);
  }
}

main();

#!/usr/bin/env node

/**
 * generate-storyboard.js
 *
 * 根据 SRT 文件和 AI 生成的分组信息，生成 storyboard.json
 *
 * 用法: node generate-storyboard.js <srtPath> <groupsPath> <outputPath>
 *
 * 输入:
 *   - srtPath: SRT 字幕文件路径
 *   - groupsPath: AI 生成的 groups.json 路径
 *   - outputPath: 输出的 storyboard.json 路径
 *
 * groups.json 格式:
 * {
 *   "groups": [
 *     {
 *       "sceneId": "scene_001",
 *       "fromIndex": 1,
 *       "toIndex": 3,
 *       "semanticTags": ["开场", "介绍"],
 *       "visualHint": "大标题居中，配合动画演示稿相关图标"
 *     },
 *     ...
 *   ]
 * }
 */

const fs = require('fs');
const path = require('path');

// ============ SRT 解析 ============

/**
 * 解析时间码为毫秒
 * @param {string} timeStr - 格式: "HH:MM:SS,mmm"
 * @returns {number} 毫秒数
 */
function parseTimeCode(timeStr) {
  const match = timeStr.trim().match(/(\d{2}):(\d{2}):(\d{2})[,.](\d{3})/);
  if (!match) {
    throw new Error(`无效的时间码格式: ${timeStr}`);
  }
  const [, hours, minutes, seconds, ms] = match;
  return (
    parseInt(hours, 10) * 3600000 +
    parseInt(minutes, 10) * 60000 +
    parseInt(seconds, 10) * 1000 +
    parseInt(ms, 10)
  );
}

/**
 * 解析 SRT 文件
 * @param {string} srtContent - SRT 文件内容
 * @returns {Array<{index: number, startMs: number, endMs: number, text: string}>}
 */
function parseSRT(srtContent) {
  const subtitles = [];

  // 按空行分割为块
  const blocks = srtContent.trim().split(/\n\s*\n/);

  for (const block of blocks) {
    const lines = block.trim().split('\n');
    if (lines.length < 3) continue;

    // 第一行: 序号
    const index = parseInt(lines[0].trim(), 10);
    if (isNaN(index)) continue;

    // 第二行: 时间码
    const timeLine = lines[1].trim();
    const timeMatch = timeLine.match(/(.+?)\s*-->\s*(.+)/);
    if (!timeMatch) continue;

    const startMs = parseTimeCode(timeMatch[1]);
    const endMs = parseTimeCode(timeMatch[2]);

    // 第三行及以后: 文本
    const text = lines.slice(2).join('\n').trim();

    subtitles.push({ index, startMs, endMs, text });
  }

  // 按序号排序
  subtitles.sort((a, b) => a.index - b.index);

  return subtitles;
}

// ============ 分组验证 ============

/**
 * 验证分组数据的完整性和连续性
 * @param {Array} groups - 分组数组
 * @param {number} totalSubtitles - SRT 字幕总数
 * @returns {{valid: boolean, errors: string[]}}
 */
function validateGroups(groups, totalSubtitles) {
  const errors = [];

  if (!groups || groups.length === 0) {
    errors.push('分组数据为空');
    return { valid: false, errors };
  }

  // 检查第一个分组的 fromIndex 是否为 1
  if (groups[0].fromIndex !== 1) {
    errors.push(`第一个分组的 fromIndex 必须为 1，实际为 ${groups[0].fromIndex}`);
  }

  // 检查最后一个分组的 toIndex 是否等于字幕总数
  const lastGroup = groups[groups.length - 1];
  if (lastGroup.toIndex !== totalSubtitles) {
    errors.push(`最后一个分组的 toIndex 必须为 ${totalSubtitles}，实际为 ${lastGroup.toIndex}`);
  }

  // 检查连续性和 sceneId 格式
  for (let i = 0; i < groups.length; i++) {
    const group = groups[i];
    const expectedSceneId = `scene_${String(i + 1).padStart(3, '0')}`;

    // 检查 sceneId 格式
    if (group.sceneId !== expectedSceneId) {
      errors.push(`分组 ${i + 1} 的 sceneId 应为 ${expectedSceneId}，实际为 ${group.sceneId}`);
    }

    // 检查 fromIndex <= toIndex
    if (group.fromIndex > group.toIndex) {
      errors.push(`分组 ${group.sceneId} 的 fromIndex (${group.fromIndex}) 大于 toIndex (${group.toIndex})`);
    }

    // 检查与前一个分组的连续性
    if (i > 0) {
      const prevGroup = groups[i - 1];
      if (group.fromIndex !== prevGroup.toIndex + 1) {
        errors.push(`分组 ${group.sceneId} 的 fromIndex (${group.fromIndex}) 与前一个分组的 toIndex (${prevGroup.toIndex}) 不连续`);
      }
    }
  }

  return {
    valid: errors.length === 0,
    errors
  };
}

// ============ 生成 Storyboard ============

/**
 * 根据分组信息生成场景
 * @param {Array} subtitles - 解析后的字幕数组
 * @param {Array} groups - 分组数组
 * @returns {Array} 场景数组
 */
function generateScenes(subtitles, groups) {
  const scenes = [];

  // 创建字幕索引映射 (index -> subtitle)
  const subtitleMap = new Map();
  for (const sub of subtitles) {
    subtitleMap.set(sub.index, sub);
  }

  for (const group of groups) {
    // 获取该分组内的所有字幕
    const groupSubtitles = [];
    for (let idx = group.fromIndex; idx <= group.toIndex; idx++) {
      const sub = subtitleMap.get(idx);
      if (sub) {
        groupSubtitles.push(sub);
      }
    }

    if (groupSubtitles.length === 0) {
      console.warn(`警告: 分组 ${group.sceneId} 没有找到对应的字幕`);
      continue;
    }

    // 计算场景的 startTime (第一条字幕的开始时间)
    const startTime = groupSubtitles[0].startMs;

    // 生成 segments，计算相对时间
    const segments = groupSubtitles.map((sub, idx) => {
      // relativeStart: 相对于场景开始的时间
      // 第一个 segment 的 relativeStart 必须为 0
      const relativeStart = idx === 0 ? 0 : sub.startMs - startTime;

      // relativeDuration: 该字幕的持续时间
      const relativeDuration = sub.endMs - sub.startMs;

      return {
        text: sub.text,
        relativeStart,
        relativeDuration
      };
    });

    // 计算场景的 duration (最后一个 segment 的 relativeStart + relativeDuration)
    const lastSegment = segments[segments.length - 1];
    const duration = lastSegment.relativeStart + lastSegment.relativeDuration;

    const scene = {
      id: group.sceneId,
      startTime,
      duration,
      segments
    };

    // 添加可选字段
    if (group.semanticTags && group.semanticTags.length > 0) {
      scene.semanticTags = group.semanticTags;
    }
    if (group.visualHint) {
      scene.visualHint = group.visualHint;
    }

    scenes.push(scene);
  }

  return scenes;
}

/**
 * 生成完整的 storyboard 数据
 * @param {Array} scenes - 场景数组
 * @returns {Object} storyboard 对象
 */
function generateStoryboard(scenes) {
  if (scenes.length === 0) {
    return {
      totalDuration: 0,
      sceneCount: 0,
      scenes: []
    };
  }

  const lastScene = scenes[scenes.length - 1];
  const totalDuration = lastScene.startTime + lastScene.duration;

  return {
    totalDuration,
    sceneCount: scenes.length,
    scenes
  };
}

function validateGeneratedScenes(storyboard) {
  const errors = [];
  const scenes = storyboard.scenes;

  if (storyboard.sceneCount !== scenes.length) {
    errors.push(`sceneCount 应为 ${scenes.length}，实际为 ${storyboard.sceneCount}`);
  }

  for (let i = 0; i < scenes.length; i++) {
    const scene = scenes[i];
    const expectedId = `scene_${String(i + 1).padStart(3, '0')}`;

    if (scene.id !== expectedId) {
      errors.push(`场景 ${i + 1} 的 id 应为 ${expectedId}，实际为 ${scene.id}`);
    }

    if (!Array.isArray(scene.segments) || scene.segments.length === 0) {
      errors.push(`场景 ${scene.id} 缺少 segments`);
      continue;
    }

    if (typeof scene.startTime !== 'number' || scene.startTime < 0) {
      errors.push(`场景 ${scene.id} 的 startTime 无效: ${scene.startTime}`);
    }

    if (typeof scene.duration !== 'number' || scene.duration <= 0) {
      errors.push(`场景 ${scene.id} 的 duration 无效: ${scene.duration}`);
    }

    let computedDuration = 0;
    let previousStart = -1;
    for (let j = 0; j < scene.segments.length; j++) {
      const segment = scene.segments[j];
      if (typeof segment.relativeStart !== 'number' || segment.relativeStart < 0) {
        errors.push(`场景 ${scene.id} 的 segment[${j}] relativeStart 无效`);
      }
      if (typeof segment.relativeDuration !== 'number' || segment.relativeDuration <= 0) {
        errors.push(`场景 ${scene.id} 的 segment[${j}] relativeDuration 无效`);
      }
      if (segment.relativeStart < previousStart) {
        errors.push(`场景 ${scene.id} 的 segments 时间未递增`);
      }
      previousStart = segment.relativeStart;
      computedDuration = Math.max(
        computedDuration,
        segment.relativeStart + segment.relativeDuration,
      );
    }

    if (computedDuration !== scene.duration) {
      errors.push(`场景 ${scene.id} 的 duration 应为 ${computedDuration}，实际为 ${scene.duration}`);
    }

    if (i > 0) {
      const prev = scenes[i - 1];
      if (scene.startTime < prev.startTime) {
        errors.push(`场景 ${scene.id} 的 startTime 小于前一个场景`);
      }
    }
  }

  const lastScene = scenes[scenes.length - 1];
  const expectedTotalDuration = lastScene ? lastScene.startTime + lastScene.duration : 0;
  if (storyboard.totalDuration !== expectedTotalDuration) {
    errors.push(`totalDuration 应为 ${expectedTotalDuration}，实际为 ${storyboard.totalDuration}`);
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

// ============ 主函数 ============

function main() {
  const args = process.argv.slice(2);

  if (args.length < 3) {
    console.error('用法: node generate-storyboard.js <srtPath> <groupsPath> <outputPath>');
    console.error('');
    console.error('参数:');
    console.error('  srtPath     SRT 字幕文件路径');
    console.error('  groupsPath  AI 生成的 groups.json 路径');
    console.error('  outputPath  输出的 storyboard.json 路径');
    process.exit(1);
  }

  const [srtPath, groupsPath, outputPath] = args;

  // 检查文件是否存在
  if (!fs.existsSync(srtPath)) {
    console.error(`错误: SRT 文件不存在: ${srtPath}`);
    process.exit(1);
  }

  if (!fs.existsSync(groupsPath)) {
    console.error(`错误: groups.json 文件不存在: ${groupsPath}`);
    process.exit(1);
  }

  try {
    // 1. 解析 SRT 文件
    console.log(`📄 解析 SRT 文件: ${srtPath}`);
    const srtContent = fs.readFileSync(srtPath, 'utf-8');
    const subtitles = parseSRT(srtContent);
    console.log(`   找到 ${subtitles.length} 条字幕`);

    // 2. 读取分组信息
    console.log(`📋 读取分组信息: ${groupsPath}`);
    const groupsContent = fs.readFileSync(groupsPath, 'utf-8');
    const groupsData = JSON.parse(groupsContent);
    const groups = groupsData.groups;
    console.log(`   找到 ${groups.length} 个分组`);

    // 3. 验证分组数据
    console.log('🔍 验证分组数据...');
    const validation = validateGroups(groups, subtitles.length);
    if (!validation.valid) {
      console.error('❌ 分组验证失败:');
      validation.errors.forEach(err => console.error(`   - ${err}`));
      process.exit(1);
    }
    console.log('   ✅ 分组验证通过');

    // 4. 生成场景
    console.log('🎬 生成场景...');
    const scenes = generateScenes(subtitles, groups);

    // 5. 生成 storyboard
    const storyboard = generateStoryboard(scenes);

    const storyboardValidation = validateGeneratedScenes(storyboard);
    if (!storyboardValidation.valid) {
      console.error('❌ storyboard 校验失败:');
      storyboardValidation.errors.forEach(err => console.error(`   - ${err}`));
      process.exit(1);
    }

    // 6. 写入文件
    console.log(`💾 写入文件: ${outputPath}`);
    fs.writeFileSync(outputPath, JSON.stringify(storyboard, null, 2), 'utf-8');

    // 7. 输出摘要
    console.log('');
    console.log('✅ 生成完成!');
    console.log(`   - 场景数量: ${storyboard.sceneCount}`);
    console.log(`   - 总时长: ${(storyboard.totalDuration / 1000).toFixed(1)}s`);
    console.log(`   - 输出文件: ${outputPath}`);

    // 输出 JSON 结果供调用方使用
    console.log('');
    console.log('__RESULT_JSON__');
    console.log(JSON.stringify({
      success: true,
      storyboardPath: outputPath,
      sceneCount: storyboard.sceneCount,
      totalDuration: storyboard.totalDuration
    }));

  } catch (error) {
    console.error(`❌ 错误: ${error.message}`);
    process.exit(1);
  }
}

main();

#!/usr/bin/env node

/**
 * 项目初始化脚本
 *
 * 用法:
 *   node init-project.js --srt-path <srt-path>
 *
 * 功能:
 *   - 从 skill 内部 template 复制创建新项目
 *   - 默认创建到字幕目录下的 remotion-video-projects/{timestamp}/
 *   - 若 template 已完成依赖安装，则会一并复制已安装依赖
 *
 * 输出:
 *   成功时输出 JSON: { projectRoot, projectName, createdAt, srtFile }
 */

const fs = require('fs');
const path = require('path');

// 路径配置
const SKILL_ROOT = path.resolve(__dirname, '..');
const TEMPLATE_DIR = path.join(SKILL_ROOT, 'template');
const PROJECTS_DIR_NAME = 'remotion-video-projects';

/**
 * 生成时间戳格式的项目名称
 */
function generateProjectName() {
  const now = new Date();
  const pad = (n) => String(n).padStart(2, '0');
  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
}

/**
 * 递归复制目录（若 template 中存在 node_modules 也会复制，正确处理符号链接）
 */
function copyDirSync(src, dest) {
  if (!fs.existsSync(dest)) {
    fs.mkdirSync(dest, { recursive: true });
  }

  const entries = fs.readdirSync(src, { withFileTypes: true });

  for (const entry of entries) {
    const srcPath = path.join(src, entry.name);
    const destPath = path.join(dest, entry.name);

    if (entry.isSymbolicLink()) {
      // 保留符号链接（相对路径链接在复制后仍然有效）
      const linkTarget = fs.readlinkSync(srcPath);
      try {
        fs.symlinkSync(linkTarget, destPath);
      } catch (e) {
        // 如果符号链接已存在，跳过
        if (e.code !== 'EEXIST') throw e;
      }
    } else if (entry.isDirectory()) {
      copyDirSync(srcPath, destPath);
    } else {
      fs.copyFileSync(srcPath, destPath);
    }
  }
}

function resolveSrtPath(inputPath) {
  if (!inputPath) {
    console.error(JSON.stringify({ error: '缺少 srtPath' }));
    process.exit(1);
  }

  return path.resolve(inputPath);
}

/**
 * 创建新项目
 */
function createNewProject(inputSrtPath) {
  // 检查 template 目录
  if (!fs.existsSync(TEMPLATE_DIR)) {
    console.error(JSON.stringify({ error: 'template 目录不存在' }));
    process.exit(1);
  }

  const srtPath = resolveSrtPath(inputSrtPath);

  if (!fs.existsSync(srtPath)) {
    console.error(JSON.stringify({ error: `SRT 文件不存在: ${srtPath}` }));
    process.exit(1);
  }

  const srtDir = path.dirname(srtPath);
  const projectsDir = path.join(srtDir, PROJECTS_DIR_NAME);

  if (!fs.existsSync(projectsDir)) {
    fs.mkdirSync(projectsDir, { recursive: true });
  }

  const projectName = generateProjectName();
  const projectRoot = path.join(projectsDir, projectName);

  // 复制 template 到新项目目录
  console.error(`正在创建项目: ${projectName}`);
  copyDirSync(TEMPLATE_DIR, projectRoot);

  return {
    projectName,
    projectRoot,
    createdAt: new Date().toISOString(),
    srtFile: srtPath
  };
}

function parseArgs(args) {
  let srtPath = null;

  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--srt-path') {
      srtPath = args[i + 1] || null;
      i += 1;
    }
  }

  return { srtPath };
}

/**
 * 主函数
 */
function main() {
  const { srtPath } = parseArgs(process.argv.slice(2));

  if (!srtPath) {
    console.error('用法: node init-project.js --srt-path <srt-path>');
    process.exit(1);
  }

  const project = createNewProject(srtPath);
  console.log(JSON.stringify(project, null, 2));
}

main();

const fs = require('fs');
const path = require('path');

const DEFAULT_VIDEO_SETTINGS = {
  profile: '1080p30',
  design: {
    width: 1920,
    height: 1080,
  },
  profiles: {
    '1080p30': {
      width: 1920,
      height: 1080,
      fps: 30,
    },
    '4k60': {
      width: 3840,
      height: 2160,
      fps: 60,
    },
  },
};

function getActiveVideoProfile(videoSettings = DEFAULT_VIDEO_SETTINGS) {
  const profileName = videoSettings.profile;
  const profile = videoSettings.profiles && videoSettings.profiles[profileName];
  if (!profile) {
    throw new Error(`未知视频输出配置: ${profileName}`);
  }

  return {
    name: profileName,
    width: profile.width,
    height: profile.height,
    fps: profile.fps,
  };
}

function loadVideoSettings(projectRoot) {
  if (!projectRoot) {
    return DEFAULT_VIDEO_SETTINGS;
  }

  const settingsPath = path.join(projectRoot, 'src', 'video-settings.json');
  if (!fs.existsSync(settingsPath)) {
    return DEFAULT_VIDEO_SETTINGS;
  }

  return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
}

function msToFrames(ms, fps = getActiveVideoProfile().fps) {
  return Math.round((ms / 1000) * fps);
}

function sceneIdToNumber(sceneId) {
  const match = /^scene_(\d{3})$/.exec(sceneId);
  if (!match) {
    throw new Error(`无效的 sceneId: ${sceneId}`);
  }

  return match[1];
}

function sceneIdToComponentName(sceneId) {
  return `Scene${sceneIdToNumber(sceneId)}`;
}

function sceneIdToFilename(sceneId) {
  return `${sceneIdToComponentName(sceneId)}.tsx`;
}

function loadStoryboard(storyboardPath) {
  if (!fs.existsSync(storyboardPath)) {
    throw new Error(`storyboard.json 不存在: ${storyboardPath}`);
  }

  const raw = fs.readFileSync(storyboardPath, 'utf-8');
  const storyboard = JSON.parse(raw);

  if (!storyboard || !Array.isArray(storyboard.scenes)) {
    throw new Error(`storyboard.json 结构无效: ${storyboardPath}`);
  }

  return storyboard;
}

function getScenesDir(projectRoot) {
  return path.join(projectRoot, 'src', 'scenes');
}

function listSceneComponentFiles(projectRoot) {
  const scenesDir = getScenesDir(projectRoot);
  if (!fs.existsSync(scenesDir)) {
    throw new Error(`场景目录不存在: ${scenesDir}`);
  }

  return fs.readdirSync(scenesDir)
    .filter((file) => /^Scene\d{3}\.tsx$/.test(file))
    .sort();
}

function validateStoryboardStructure(storyboard) {
  const errors = [];
  const scenes = storyboard.scenes;

  if (storyboard.sceneCount !== scenes.length) {
    errors.push(`sceneCount 应为 ${scenes.length}，实际为 ${storyboard.sceneCount}`);
  }

  for (let i = 0; i < scenes.length; i++) {
    const scene = scenes[i];
    const expectedId = `scene_${String(i + 1).padStart(3, '0')}`;

    if (scene.id !== expectedId) {
      errors.push(`场景 ${i + 1} 的 id 应为 ${expectedId}，实际为 ${scene.id}`);
    }

    if (!Array.isArray(scene.segments) || scene.segments.length === 0) {
      errors.push(`场景 ${scene.id} 缺少 segments`);
      continue;
    }

    if (typeof scene.startTime !== 'number' || scene.startTime < 0) {
      errors.push(`场景 ${scene.id} 的 startTime 无效: ${scene.startTime}`);
    }

    if (typeof scene.duration !== 'number' || scene.duration <= 0) {
      errors.push(`场景 ${scene.id} 的 duration 无效: ${scene.duration}`);
    }

    let computedDuration = 0;
    let previousRelativeStart = -1;
    for (let j = 0; j < scene.segments.length; j++) {
      const segment = scene.segments[j];
      if (typeof segment.relativeStart !== 'number' || segment.relativeStart < 0) {
        errors.push(`场景 ${scene.id} 的 segment[${j}] relativeStart 无效`);
      }
      if (typeof segment.relativeDuration !== 'number' || segment.relativeDuration <= 0) {
        errors.push(`场景 ${scene.id} 的 segment[${j}] relativeDuration 无效`);
      }
      if (segment.relativeStart < previousRelativeStart) {
        errors.push(`场景 ${scene.id} 的 segments 时间未递增`);
      }
      previousRelativeStart = segment.relativeStart;
      computedDuration = Math.max(
        computedDuration,
        segment.relativeStart + segment.relativeDuration,
      );
    }

    if (computedDuration !== scene.duration) {
      errors.push(`场景 ${scene.id} 的 duration 应为 ${computedDuration}，实际为 ${scene.duration}`);
    }

    if (i > 0) {
      const prev = scenes[i - 1];
      if (scene.startTime < prev.startTime) {
        errors.push(`场景 ${scene.id} 的 startTime 小于前一个场景`);
      }
    }
  }

  const lastScene = scenes[scenes.length - 1];
  const expectedTotalDuration = lastScene
    ? lastScene.startTime + lastScene.duration
    : 0;

  if (storyboard.totalDuration !== expectedTotalDuration) {
    errors.push(`totalDuration 应为 ${expectedTotalDuration}，实际为 ${storyboard.totalDuration}`);
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

function validateSceneFilesAgainstStoryboard(projectRoot, storyboard) {
  const errors = [];
  const actualFiles = listSceneComponentFiles(projectRoot);
  const expectedFiles = storyboard.scenes.map((scene) => sceneIdToFilename(scene.id));

  for (const expectedFile of expectedFiles) {
    if (!actualFiles.includes(expectedFile)) {
      errors.push(`缺少场景文件: ${expectedFile}`);
    }
  }

  for (const actualFile of actualFiles) {
    if (!expectedFiles.includes(actualFile)) {
      errors.push(`存在未被 storyboard 引用的场景文件: ${actualFile}`);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
    actualFiles,
    expectedFiles,
  };
}

function validateSceneComponentExports(projectRoot, storyboard) {
  const errors = [];

  for (const scene of storyboard.scenes) {
    const filePath = path.join(getScenesDir(projectRoot), sceneIdToFilename(scene.id));
    if (!fs.existsSync(filePath)) {
      continue;
    }

    const content = fs.readFileSync(filePath, 'utf-8');
    const componentName = sceneIdToComponentName(scene.id);

    if (!content.includes(`export default ${componentName}`)) {
      errors.push(`场景 ${scene.id} 必须使用默认导出：export default ${componentName}`);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

function analyzeSceneTimingUsage(content) {
  const normalized = content.replace(/\r\n/g, '\n');
  const segmentAliasNames = new Set();
  const segmentAccessorNames = new Set();
  const directSegmentIndexes = new Set();

  for (const pattern of [/\b(?:const|let|var)\s+(\w+)\s*=\s*segments\b/g]) {
    let match;
    while ((match = pattern.exec(normalized)) !== null) {
      segmentAliasNames.add(match[1]);
    }
  }

  for (const pattern of [
    /\bsegments\s*\[\s*(\d+)\s*\]/g,
  ]) {
    let match;
    while ((match = pattern.exec(normalized)) !== null) {
      directSegmentIndexes.add(Number(match[1]));
    }
  }

  for (const pattern of [
    /\bconst\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*segments\s*\[[^\]]+\]/g,
    /\b(?:let|var)\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*segments\s*\[[^\]]+\]/g,
    /\bfunction\s+(\w+)\s*\([^)]*\)\s*\{\s*return\s+segments\s*\[[^\]]+\][\s\S]*?\}/g,
  ]) {
    let match;
    while ((match = pattern.exec(normalized)) !== null) {
      segmentAccessorNames.add(match[1]);
    }
  }

  const declaresSegmentsProp = /segments\??\s*:\s*Array<\{[\s\S]*?relativeStart[\s\S]*?\}>/.test(normalized)
    || /segments\??\s*:\s*Segment\[\]/.test(normalized)
    || /\(\{\s*segments\s*=/.test(normalized)
    || /\(\{\s*segments\s*\}\s*\)/.test(normalized);

  const usesSegmentsCollectionPatterns = [
    /segments\.map\(/,
    /segments\.forEach\(/,
    /segments\.reduce\(/,
    /segments\.filter\(/,
    /segments\s*\[/,
    /for\s*\(\s*const\s+\w+\s+of\s+segments\s*\)/,
    /for\s*\(\s*let\s+\w+\s*=\s*0;\s*\w+\s*<\s*segments\.length/,
  ];
  const usesSegmentsCollection = usesSegmentsCollectionPatterns.some((pattern) => pattern.test(normalized))
    || segmentAliasNames.size > 0
    || segmentAccessorNames.size > 0;

  const suspiciousTimingPatterns = [
    /\bconst\s+(?:beat|b\d+|phase\d+|seg\d+)\w*\s*=\s*(?:msToFrames?|framesFromMs)\(\s*\d{3,}\b/g,
    /\bconst\s+(?:beat|b\d+|phase\d+|seg\d+)\w*(?:Ms|Start|End|Frame|Frames)\s*=\s*\d{3,}\b/g,
    /\b(?:msToFrames?|framesFromMs)\(\s*\d{3,}\s*,/g,
  ];
  const suspiciousTimingMatches = suspiciousTimingPatterns.flatMap((pattern) => normalized.match(pattern) || []);
  const hasSuspiciousHardcodedTiming = suspiciousTimingMatches.length > 0;

  const usesLaterBeatEvidencePatterns = [
    /segments\s*\[\s*1\s*\]/,
    /segments\s*\[\s*2\s*\]/,
    /seg2Start/,
    /seg3Start/,
    /segmentStartFrames?\s*\[\s*1\s*\]/,
    /segmentStartFrames?\s*\[\s*2\s*\]/,
    /segments\.map\(/,
    /for\s*\(\s*const\s+\w+\s+of\s+segments\s*\)/,
  ];
  const usesLaterBeatEvidence = usesLaterBeatEvidencePatterns.some((pattern) => pattern.test(normalized))
    || Array.from(segmentAccessorNames).some((name) => {
      const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
      return new RegExp(`\\b${escaped}\\s*\\(\\s*[12]\\s*\\)`).test(normalized);
    });

  return {
    declaresSegmentsProp,
    directSegmentIndexes: [...directSegmentIndexes].sort((a, b) => a - b),
    usesSegmentsCollection,
    hasSuspiciousHardcodedTiming,
    suspiciousTimingMatches,
    usesLaterBeatEvidence,
  };
}

function validateSceneTimingAgainstStoryboard(projectRoot, storyboard) {
  const errors = [];
  const warnings = [];

  for (const scene of storyboard.scenes) {
    const filePath = path.join(getScenesDir(projectRoot), sceneIdToFilename(scene.id));
    if (!fs.existsSync(filePath)) {
      continue;
    }

    const content = fs.readFileSync(filePath, 'utf-8');
    const analysis = analyzeSceneTimingUsage(content);
    const segmentCount = Array.isArray(scene.segments) ? scene.segments.length : 0;

    if (segmentCount > 1 && analysis.declaresSegmentsProp && !analysis.usesSegmentsCollection) {
      errors.push(`场景 ${scene.id} 已声明 segments 接口，但实现中未真实消费 segments 数据`);
      continue;
    }

    if (segmentCount > 1 && analysis.hasSuspiciousHardcodedTiming) {
      const sample = analysis.suspiciousTimingMatches[0]?.replace(/\s+/g, ' ').trim();
      errors.push(
        `场景 ${scene.id} 检测到疑似硬编码时序拍点` + (sample ? `（例如：${sample}）` : '')
      );
      continue;
    }

    if (segmentCount > 1 && !analysis.declaresSegmentsProp && analysis.usesSegmentsCollection) {
      warnings.push(`场景 ${scene.id} 可能通过中间变量间接消费 segments，建议检查是否显式按 beat 绑定使用 segments`);
    }

    if (segmentCount >= 3 && !analysis.usesLaterBeatEvidence) {
      warnings.push(`场景 ${scene.id} 可能缺少后续拍点展开，建议检查是否把主要内容过早堆在前段`);
    }

    const outOfRangeSegmentIndex = analysis.directSegmentIndexes.find((index) => index >= segmentCount);
    if (typeof outOfRangeSegmentIndex === 'number') {
      errors.push(`场景 ${scene.id} 访问了越界的 segments[${outOfRangeSegmentIndex}]，当前仅有 ${segmentCount} 个 segments`);
    }
  }

  return {
    valid: errors.length === 0,
    errors,
    warnings,
  };
}

function buildGeneratedScenesSource(storyboard, options = {}) {
  const fps = options.fps || getActiveVideoProfile(options.videoSettings).fps;
  const imports = storyboard.scenes
    .map((scene) => {
      const componentName = sceneIdToComponentName(scene.id);
      return `import ${componentName} from "../scenes/${componentName}";`;
    })
    .join('\n');

  const sceneEntries = storyboard.scenes
    .map((scene) => {
      const componentName = sceneIdToComponentName(scene.id);
      const segmentsStr = JSON.stringify(scene.segments, null, 6)
        .split('\n')
        .map((line, i) => i === 0 ? line : '      ' + line)
        .join('\n');
      return `  {\n    start: ${scene.startTime},\n    duration: ${scene.duration},\n    segments: ${segmentsStr},\n    Component: ${componentName},\n  },`;
    })
    .join('\n');

  return `import type React from "react";

${imports}

type Segment = {
  text: string;
  relativeStart: number;
  relativeDuration: number;
};

export type GeneratedSceneItem = {
  start: number;
  duration: number;
  segments: Segment[];
  Component: React.FC<{ segments: Segment[] }>;
};

export const generatedScenes: GeneratedSceneItem[] = [
${sceneEntries}
];

export const totalDurationInFrames = ${msToFrames(storyboard.totalDuration, fps)};
`;
}

module.exports = {
  analyzeSceneTimingUsage,
  DEFAULT_VIDEO_SETTINGS,
  buildGeneratedScenesSource,
  getActiveVideoProfile,
  getScenesDir,
  listSceneComponentFiles,
  loadStoryboard,
  loadVideoSettings,
  msToFrames,
  sceneIdToComponentName,
  sceneIdToFilename,
  validateSceneComponentExports,
  validateSceneFilesAgainstStoryboard,
  validateSceneTimingAgainstStoryboard,
  validateStoryboardStructure,
};

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

const {
  buildGeneratedScenesSource,
  getActiveVideoProfile,
  loadStoryboard,
  loadVideoSettings,
  validateSceneComponentExports,
  validateSceneFilesAgainstStoryboard,
  validateSceneTimingAgainstStoryboard,
  validateStoryboardStructure,
} = require('./scene-registry-utils');

function validateRoot(rootPath) {
  const errors = [];
  if (!fs.existsSync(rootPath)) {
    errors.push(`缺少 Root.tsx: ${rootPath}`);
    return { valid: false, errors };
  }

  const content = fs.readFileSync(rootPath, 'utf-8');
  if (!content.includes('import { totalDurationInFrames } from "./compositions/generated-scenes";')) {
    errors.push('Root.tsx 未从 generated-scenes.ts 导入 totalDurationInFrames');
  }
  if (!content.includes('durationInFrames={totalDurationInFrames}')) {
    errors.push('Root.tsx 未使用 totalDurationInFrames 作为 Composition.durationInFrames');
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

function validateMain(mainPath) {
  const errors = [];
  if (!fs.existsSync(mainPath)) {
    errors.push(`缺少 Main.tsx: ${mainPath}`);
    return { valid: false, errors };
  }

  const content = fs.readFileSync(mainPath, 'utf-8');
  if (!content.includes('import { generatedScenes }')) {
    errors.push('Main.tsx 未导入 generatedScenes');
  }
  if (!content.includes('generatedScenes.map((scene, index) =>')) {
    errors.push('Main.tsx 未使用 generatedScenes 渲染场景序列');
  }
  if (!content.includes('<Component segments={scene.segments} />')) {
    errors.push('Main.tsx 未通过 <Component segments={scene.segments} /> 向场景组件传递分段数据');
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

function validateRegistry(registryPath, storyboard, videoSettings) {
  const errors = [];
  if (!fs.existsSync(registryPath)) {
    errors.push(`缺少 generated-scenes.ts: ${registryPath}`);
    return { valid: false, errors };
  }

  const actual = fs.readFileSync(registryPath, 'utf-8').trim();
  const expected = buildGeneratedScenesSource(storyboard, { videoSettings }).trim();
  if (actual !== expected) {
    errors.push('generated-scenes.ts 与 storyboard.json / 场景文件不一致');
  }

  return {
    valid: errors.length === 0,
    errors,
  };
}

function main() {
  const args = process.argv.slice(2);
  if (args.length < 2) {
    console.error('用法: node validate-project.js <projectRoot> <storyboardPath>');
    process.exit(1);
  }

  const [projectRoot, storyboardPath] = args;
  const rootPath = path.join(projectRoot, 'src', 'Root.tsx');
  const mainPath = path.join(projectRoot, 'src', 'compositions', 'Main.tsx');
  const registryPath = path.join(projectRoot, 'src', 'compositions', 'generated-scenes.ts');

  try {
    const storyboard = loadStoryboard(storyboardPath);
    const videoSettings = loadVideoSettings(projectRoot);
    const activeProfile = getActiveVideoProfile(videoSettings);
    const validations = [
      validateStoryboardStructure(storyboard),
      validateSceneFilesAgainstStoryboard(projectRoot, storyboard),
      validateSceneComponentExports(projectRoot, storyboard),
      validateSceneTimingAgainstStoryboard(projectRoot, storyboard),
      validateRegistry(registryPath, storyboard, videoSettings),
      validateRoot(rootPath),
      validateMain(mainPath),
    ];

    const errors = validations.flatMap((result) => result.errors);
    const warnings = validations.flatMap((result) => result.warnings || []);
    if (errors.length > 0) {
      console.error('❌ 项目校验失败:');
      errors.forEach((error) => console.error(`   - ${error}`));
      process.exit(1);
    }

    if (warnings.length > 0) {
      console.warn('⚠️ 项目校验告警:');
      warnings.forEach((warning) => console.warn(`   - ${warning}`));
    }

    console.log('✅ 项目校验通过');
    console.log(`   - projectRoot: ${projectRoot}`);
    console.log(`   - storyboard: ${storyboardPath}`);
    console.log(`   - sceneCount: ${storyboard.sceneCount}`);
    console.log(`   - videoProfile: ${activeProfile.width}x${activeProfile.height} / ${activeProfile.fps}fps (${activeProfile.name})`);
    console.log('');
    console.log('__RESULT_JSON__');
    console.log(JSON.stringify({
      success: true,
      projectRoot,
      storyboardPath,
      sceneCount: storyboard.sceneCount,
      videoProfile: activeProfile,
    }));
  } catch (error) {
    console.error(`❌ 错误: ${error.message}`);
    process.exit(1);
  }
}

main();