@amg555/frameforge-mcp 2.4.9 → 2.7.0

package/src/cli/doctor.js

@@ -126,7 +126,27 @@ if (hasPlaywright && hasChromium) {
     '    (Path 1 via create_video_from_script does not need Playwright)');
 }
 
-// 6. System Font (for video subtitles/captions)
+// 6. Media Downloader (yt-dlp)
+const { detectYtDlp } = require('../utils/media-downloader');
+if (detectYtDlp()) {
+  const ytdlpVer = spawnSync('yt-dlp', ['--version'], { encoding: 'utf8', timeout: 3000, shell: process.platform === 'win32' });
+  pass('Media Downloader (yt-dlp)', `available (${(ytdlpVer.stdout || '').trim()})`);
+} else {
+  warn('Media Downloader (yt-dlp)', 'yt-dlp not found in PATH (optional for downloading web clips/audio)',
+    'Run "pip install yt-dlp" or download binary from https://github.com/yt-dlp/yt-dlp');
+}
+
+// 7. Speech Transcription (Whisper)
+const { detectWhisper } = require('../utils/transcribe');
+const whisperStatus = detectWhisper();
+if (whisperStatus.available) {
+  pass('Speech Transcription (Whisper)', `engine: ${whisperStatus.engine} (word-level timestamps & pause detection ready)`);
+} else {
+  warn('Speech Transcription (Whisper)', 'Local whisper engine not detected (FFmpeg pause detection fallback active)',
+    'Run "pip install openai-whisper" for local word-level transcription or set OPENAI_API_KEY in .env');
+}
+
+// 8. System Font (for video subtitles/captions)
 const FONT_CANDIDATES = [
   'C:\\Windows\\Fonts\\arialbd.ttf',
   'C:\\Windows\\Fonts\\calibrib.ttf',
@@ -188,7 +208,21 @@ if (hasLLMKey) {
   );
 }
 
-// 7. Output directory check
+// 10. Upstream Frontier Skills & Repo Sync
+const { getUpstreamSummary } = require('../skills/sync-upstream');
+const upstream = getUpstreamSummary();
+if (upstream.hasUpdates) {
+  pass('Upstream Skills', `${upstream.repoCount} frontier repos tracked (${upstream.pendingUpdates.length} updates applied)`);
+  for (const u of upstream.pendingUpdates) {
+    console.log(`    ${COLORS.cyan}↳ [${u.category}] ${u.repo} (${u.userImpact})${COLORS.reset}`);
+  }
+} else if (upstream.lastSync) {
+  pass('Upstream Skills', `${upstream.repoCount} frontier repos synced (HyperFrames, OneTake, LemoOpuscar, Remotion, Earshot, ClaudeAnimationBase)`);
+} else {
+  warn('Upstream Skills', 'Not yet synchronized with upstream frontier repos', 'Run "frameforge sync" to check and apply latest animation and editing techniques');
+}
+
+// 11. Output directory check
 const baseDir = process.env.N8N_FILES_DIR || path.join(process.cwd(), '.frameforge-files');
 try {
   fs.mkdirSync(baseDir, { recursive: true });

package/src/cli/make.js

@@ -83,16 +83,107 @@ const LANGUAGE_VOICES = {
   'id':    'id-ID-ArdiNeural',      // Indonesian
 };
 
-// ── Argument parsing ──────────────────────────────────────────────────────────
+// ── Subcommand Dispatcher ─────────────────────────────────────────────────────
 
-// Dispatch to code-driven animation harness if invoked as `frameforge harness ...`
-if (process.argv[2] === 'harness') {
+const subCmd = (process.argv[2] || '').toLowerCase();
+
+// 1. Dispatch to code-driven animation harness
+if (subCmd === 'harness') {
   const harnessBin = path.resolve(__dirname, '../harness/bin/harness.mjs');
   const { spawnSync } = require('child_process');
   const res = spawnSync(process.execPath, [harnessBin, ...process.argv.slice(3)], { stdio: 'inherit' });
   process.exit(res.status ?? 0);
 }
 
+// 2. Dispatch to media downloader (yt-dlp)
+if (subCmd === 'download' || subCmd === 'ingest') {
+  const url = process.argv[3];
+  if (!url || url.startsWith('-')) {
+    console.error('Usage: frameforge download <url> [--audio] [--subtitles] [--out-dir <dir>] [--filename <name>]');
+    process.exit(1);
+  }
+  const isAudio = process.argv.includes('--audio') || process.argv.includes('-a');
+  const sub = process.argv.includes('--subtitles') || process.argv.includes('--subs');
+  let outDir, filename;
+  for (let i = 4; i < process.argv.length; i++) {
+    if (process.argv[i] === '--out-dir' || process.argv[i] === '-o') outDir = process.argv[++i];
+    if (process.argv[i] === '--filename' || process.argv[i] === '-f') filename = process.argv[++i];
+  }
+  const { downloadMediaWithYtDlp, detectYtDlp } = require('../utils/media-downloader');
+  if (!detectYtDlp()) {
+    console.error('✖ yt-dlp is not installed. Install with: pip install yt-dlp');
+    process.exit(1);
+  }
+  try {
+    console.log(`⬇️  Downloading with yt-dlp: ${url}`);
+    const res = downloadMediaWithYtDlp(url, { format: isAudio ? 'audio' : 'video', subtitles: sub, outputDir: outDir, filename });
+    console.log(`✔ Downloaded successfully to: ${res.localPath}`);
+    if (res.subtitlePath) console.log(`✔ Subtitles saved to: ${res.subtitlePath}`);
+    if (res.duration) console.log(`  Duration: ${res.duration.toFixed(1)}s (${res.width || 0}x${res.height || 0})`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`✖ Download failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// 3. Dispatch to speech transcription (Whisper)
+if (subCmd === 'transcribe') {
+  const mediaPath = process.argv[3];
+  if (!mediaPath || mediaPath.startsWith('-')) {
+    console.error('Usage: frameforge transcribe <mediaPath> [--model <model>] [--language <lang>] [--format <ndjson|srt|json|all>] [--out <path>]');
+    process.exit(1);
+  }
+  let model = 'base', language, format = 'all', outputPath;
+  for (let i = 4; i < process.argv.length; i++) {
+    if (process.argv[i] === '--model' || process.argv[i] === '-m') model = process.argv[++i];
+    if (process.argv[i] === '--language' || process.argv[i] === '-l') language = process.argv[++i];
+    if (process.argv[i] === '--format' || process.argv[i] === '-f') format = process.argv[++i];
+    if (process.argv[i] === '--out' || process.argv[i] === '-o') outputPath = process.argv[++i];
+  }
+  const { transcribeAudio, detectWhisper } = require('../utils/transcribe');
+  const engine = detectWhisper();
+  console.log(`🎙️  Transcribing with Whisper (${engine.engine}, model: ${model}): ${mediaPath}`);
+  transcribeAudio(mediaPath, { model, language, format, outputPath })
+    .then(res => {
+      console.log(`✔ Transcription complete (${res.duration.toFixed(1)}s, ${res.words.length} words, ${res.segments.length} segments, ${res.pauses.length} pauses)`);
+      if (res.files) {
+        for (const [fmt, p] of Object.entries(res.files)) {
+          console.log(`  ↳ [${fmt.toUpperCase()}] ${p}`);
+        }
+      }
+      process.exit(0);
+    })
+    .catch(err => {
+      console.error(`✖ Transcription failed: ${err.message}`);
+      process.exit(1);
+    });
+}
+
+// 4. Dispatch to upstream skills synchronizer
+if (subCmd === 'sync' || subCmd === 'sync-skills' || subCmd === 'update') {
+  const isSilent = process.argv.includes('--silent');
+  const { syncSkills } = require('../skills/sync-upstream');
+  syncSkills({ silent: isSilent })
+    .then(() => process.exit(0))
+    .catch(err => {
+      console.error(`✖ Upstream sync failed: ${err.message}`);
+      process.exit(1);
+    });
+}
+
+// 5. Dispatch to doctor
+if (subCmd === 'doctor') {
+  require('./doctor');
+  return;
+}
+
+// 6. Dispatch to setup
+if (subCmd === 'setup') {
+  require('./setup-keys');
+  return;
+}
+
 function parseArgs(argv) {
   const args = {
     mode: 'full-auto',
@@ -151,7 +242,17 @@ function parseArgs(argv) {
 
 function printHelp() {
   console.log(`
-FrameForge Make — Flexible Video Generator
+FrameForge — Unified AI Video Production Engine
+
+SUBCOMMANDS:
+  download <url>     Download video/audio from web (YouTube, Twitter, Vimeo, etc.) via yt-dlp
+                     Options: [--audio] [--subtitles] [--out-dir <dir>] [--filename <name>]
+  transcribe <file>  Transcribe speech to word-level timestamps & subtitles via Whisper
+                     Options: [--model <size>] [--language <code>] [--format srt|ndjson|json|all]
+  sync               Synchronize skills from 9 upstream frontier repositories
+  doctor             Pre-flight environment diagnostics (FFmpeg, Whisper, yt-dlp, Playwright)
+  setup              Configure API keys (~/.frameforge/config.json)
+  harness            Run HTML code-driven animation test harness (Playwright + Chromium)
 
 MODES:
   full-auto    (default) Research → Script → AI Images → TTS → Render → Publish
@@ -674,8 +775,11 @@ function summarise(startTime) {
   console.log(`\n⏱️   Total time: ${mins > 0 ? `${mins}m ` : ''}${secs}s\n`);
 }
 
-main().catch(err => {
-  console.error(`\n❌  Fatal error: ${err.message}`);
-  if (process.env.DEBUG_PROVIDERS) console.error(err.stack);
-  process.exit(1);
-});
+const KNOWN_SUBCMDS = ['harness', 'download', 'ingest', 'transcribe', 'sync', 'sync-skills', 'update', 'doctor', 'setup'];
+if (!KNOWN_SUBCMDS.includes(subCmd)) {
+  main().catch(err => {
+    console.error(`\n❌  Fatal error: ${err.message}`);
+    if (process.env.DEBUG_PROVIDERS) console.error(err.stack);
+    process.exit(1);
+  });
+}

package/src/harness/bin/harness.mjs

@@ -162,9 +162,20 @@ async function cmdSheet() {
   const page = await openPageWithVirtualClock({ browser, htmlPath: HTML_FILE });
   const outPath = flags.out ? path.resolve(CWD, flags.out) : path.join(CHECK_DIR, 'sheet.jpg');
 
-  let times = [0.1, 0.5, 1.0, 1.5, 2.0];
+  let times;
   if (flags.times) {
     times = flags.times.split(',').map(Number).filter(n => !isNaN(n));
+  } else {
+    // Auto-derive timestamps from scene duration so long films get full coverage.
+    // A 60s film at the old [0.1, 0.5, 1.0, 1.5, 2.0] default covers only the first 3%.
+    const duration = await page.evaluate(() =>
+      window.DURATION || window.REEL?.duration || 5
+    );
+    const step = Math.max(0.5, duration / 20);
+    const count = Math.min(20, Math.ceil(duration / step));
+    times = Array.from({ length: count }, (_, i) =>
+      parseFloat(((i + 1) * step).toFixed(2))
+    );
   }
 
   console.log(`🖼 Generating Contact Sheet (${times.length} frames) → ${outPath}`);
@@ -307,12 +318,12 @@ async function cmdPixels() {
 }
 
 async function cmdQuality() {
-  console.log(`🎯 Running Closed-Loop Visual QA Gate (1–10 Scoring) on: ${HTML_PATH}`);
+  console.log(`🎯 Running Closed-Loop Visual QA Gate (1–10 Scoring) on: ${HTML_FILE}`);
   const { browser } = await launchHarnessBrowser();
   const sheetTarget = path.join(CHECK_DIR, 'sheet.jpg');
   const res = await verifySceneQuality({
     browser,
-    htmlPath: HTML_PATH,
+    htmlPath: HTML_FILE,
     sheetPath: sheetTarget,
   });
   await browser.close();
@@ -333,10 +344,32 @@ async function cmdQuality() {
   }
 }
 
+async function cmdLook() {
+  console.log(`🔍 Running Stage & Asset Diagnostic Linter: ${HTML_FILE}`);
+  const lookCandidates = [
+    path.join(CWD, 'scripts', 'look.mjs'),
+    path.resolve(__dirname, '../../../plugins/video-pipeline/skills/video-pipeline/assets/project/scripts/look.mjs'),
+    path.join(__dirname, 'look.mjs'),
+  ];
+  const lookScript = lookCandidates.find(p => fs.existsSync(p));
+  if (lookScript) {
+    const lookArgs = [lookScript];
+    if (flags.strict) lookArgs.push('--strict');
+    const res = spawnSync('node', lookArgs, { stdio: 'inherit', cwd: CWD });
+    if (res.status !== 0) {
+      console.error('❌ Look diagnostics failed. Resolve asset or stage errors before rendering.');
+      process.exit(1);
+    }
+  } else {
+    console.log('  ⚠️ look.mjs not found in project scripts, skipping DOM linter.');
+  }
+}
+
 async function cmdAll() {
-  console.log('🚀 Running Complete Production Pipeline: Storyboard → Verify → Quality → Frames → Encode → Inspect');
+  console.log('🚀 Running Complete Production Pipeline: Doctor → Storyboard → Look → Sheet → Verify → Quality → Frames → Encode');
   await cmdDoctor();
   await cmdStoryboard();
+  await cmdLook();
   await cmdSheet();
   await cmdVerify();
   await cmdQuality();
@@ -345,10 +378,98 @@ async function cmdAll() {
   console.log('\n✨ Production complete! Output ready at out/film.mp4');
 }
 
+/**
+ * Golden stills regression — save or check.
+ *
+ * harness golden --save   Capture 4-keyframe storyboard and write hashes to
+ *                         out/check/golden.json. Run after a video passes QC.
+ * harness golden --check  Re-capture the same 4 keyframes and compare hashes.
+ *                         Fails if any frame hash changed (refactor broke determinism).
+ * harness golden --out <path>  Custom path for golden.json (default: out/check/golden.json)
+ */
+async function cmdGolden() {
+  const goldenPath = flags.out
+    ? path.resolve(CWD, flags.out)
+    : path.join(CHECK_DIR, 'golden.json');
+
+  const { browser } = await launchHarnessBrowser({
+    softGl: flags['soft-gl'],
+    chromePath: flags.chrome,
+  });
+  const page = await openPageWithVirtualClock({ browser, htmlPath: HTML_FILE });
+
+  // Resolve duration
+  const duration = await page.evaluate(() =>
+    window.DURATION || window.REEL?.duration || 5
+  );
+
+  // 4 canonical keyframes (0%, 33%, 66%, 99%)
+  const goldenTimes = [
+    parseFloat((duration * 0.01).toFixed(3)),
+    parseFloat((duration * 0.33).toFixed(3)),
+    parseFloat((duration * 0.66).toFixed(3)),
+    parseFloat((duration * 0.99).toFixed(3)),
+  ];
+
+  async function captureHashes() {
+    const hashes = {};
+    for (const t of goldenTimes) {
+      const buf = await captureFrame(page, t, { type: 'image/png' });
+      const { createHash } = await import('crypto');
+      hashes[String(t)] = createHash('sha256').update(buf).digest('hex').slice(0, 16);
+    }
+    return hashes;
+  }
+
+  if (flags.save) {
+    console.log(`🟡 Golden: capturing ${goldenTimes.length} keyframes → ${goldenPath}`);
+    const hashes = await captureHashes();
+    fs.writeFileSync(goldenPath, JSON.stringify({ htmlFile: HTML_FILE, duration, times: goldenTimes, hashes }, null, 2), 'utf8');
+    await browser.close();
+    console.log(`  ✅ Golden baseline saved: ${goldenPath}`);
+    for (const [t, h] of Object.entries(hashes)) {
+      console.log(`     t=${t}s  hash=${h}`);
+    }
+  } else if (flags.check) {
+    if (!fs.existsSync(goldenPath)) {
+      console.error(`❌ No golden baseline found at ${goldenPath}. Run: harness golden --save first.`);
+      process.exit(1);
+    }
+    const baseline = JSON.parse(fs.readFileSync(goldenPath, 'utf8'));
+    console.log(`🔎 Golden: comparing against baseline (${baseline.times.length} frames) → ${goldenPath}`);
+    const current = await captureHashes();
+    await browser.close();
+
+    let passed = true;
+    for (const t of baseline.times) {
+      const key = String(t);
+      const expected = baseline.hashes[key];
+      const actual   = current[key];
+      if (expected !== actual) {
+        passed = false;
+        console.error(`  ❌ REGRESSION at t=${t}s  expected=${expected}  got=${actual}`);
+      } else {
+        console.log(`  ✅ t=${t}s  hash=${actual} (matches)`);
+      }
+    }
+
+    if (!passed) {
+      console.error('\n❌ GOLDEN CHECK FAILED — refactor broke determinism. Investigate edit.js changes.');
+      process.exit(1);
+    } else {
+      console.log('\n✅ GOLDEN CHECK PASSED — all keyframe hashes match baseline.');
+    }
+  } else {
+    await browser.close();
+    console.log('Usage: harness golden --save   (capture baseline)\n       harness golden --check  (verify against baseline)');
+  }
+}
+
 try {
   switch (command) {
     case 'doctor':     await cmdDoctor();     break;
     case 'storyboard': await cmdStoryboard(); break;
+    case 'look':       await cmdLook();       break;
     case 'verify':     await cmdVerify();     break;
     case 'quality':    await cmdQuality();    break;
     case 'sheet':      await cmdSheet();      break;
@@ -357,9 +478,10 @@ try {
     case 'frames':     await cmdFrames();     break;
     case 'encode':     await cmdEncode();     break;
     case 'pixels':     await cmdPixels();     break;
+    case 'golden':     await cmdGolden();     break;
     case 'all':        await cmdAll();        break;
     default:
-      console.log(`Usage: harness <doctor|storyboard|verify|quality|sheet|strip|crop|frames|encode|pixels|all> [options]`);
+      console.log(`Usage: harness <doctor|storyboard|look|verify|quality|sheet|strip|crop|frames|encode|pixels|golden|all> [options]`);
       break;
   }
 } catch (err) {