@viralspin/mcp 0.1.0 → 0.2.0

package/engine/assemble.mjs

@@ -0,0 +1,476 @@
+#!/usr/bin/env node
+/**
+ * Local video-assembly engine (Node-only — no Python, bundled ffmpeg).
+ *   node assemble.mjs --aroll <path|url> [--broll <path|url|folder> ...] [--prompt] [--style-ref]
+ *                     [--format 9x16|1x1|16x9] [--out]
+ *   node assemble.mjs --suggest <cutIdx>           (rank alternatives for a cut)
+ *   node assemble.mjs --swap <cutIdx> <assetName>  (swap a cut + re-render)
+ * Pipeline: stage A-roll -> transcribe -> rank albums -> album-weighted B-roll -> analyze ->
+ * (rotate) -> editorial -> captions -> face-aware Remotion render. Prints "RESULT:<mp4>".
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import ffmpegStatic from "ffmpeg-static";
+import ffprobeStatic from "ffprobe-static";
+import { transcribe, analyzeFrame, rankAlbums, inferStyle, editTimeline, getDirectorDecisions, inferCaptionStyle } from "./gemini.mjs";
+import os from "node:os";
+
+const FFMPEG = ffmpegStatic;
+const FFPROBE = ffprobeStatic.path;
+const EXPLAINER_INDEX_ID = process.env.EXPLAINER_INDEX_ID || "";
+const TL_KEY = process.env.TWELVE_LABS_API_KEY || "";
+const TL_BASE = "https://api.twelvelabs.io/v1.2";
+const LONG_VIDEO_SECS = 120;
+
+// Read the Twelve Labs video cache written by index_explainer_sources.
+const VIRALSPIN_HOME = path.join(os.homedir(), ".viralspin");
+const EXPLAINER_CACHE_FILE = path.join(VIRALSPIN_HOME, "explainer_cache.json");
+function readExplainerCache() {
+  try { return JSON.parse(fs.readFileSync(EXPLAINER_CACHE_FILE, "utf8")); } catch { return { videos: {} }; }
+}
+function localPathFromVideoId(videoId, cache) {
+  for (const [key, v] of Object.entries(cache.videos || {})) {
+    if (v.video_id === videoId) return key.split("|")[0];
+  }
+  return null;
+}
+
+async function tlSearch(query, indexId) {
+  try {
+    const r = await fetch(`${TL_BASE}/search`, {
+      method: "POST",
+      headers: { "x-api-key": TL_KEY, "Content-Type": "application/json" },
+      body: JSON.stringify({ index_id: indexId, query_text: query, options: ["visual", "conversation", "text_in_video"] }),
+    });
+    if (!r.ok) return [];
+    const data = await r.json();
+    return (data.data || []).slice(0, 3);
+  } catch { return []; }
+}
+const ENGINE = path.dirname(fileURLToPath(import.meta.url));
+const PUBLIC = path.join(ENGINE, "public");
+const BROLL = path.join(PUBLIC, "broll");
+const RUN = path.join(ENGINE, "_run");
+const CACHE = path.join(ENGINE, "cache");
+const IMG = new Set([".jpg", ".jpeg", ".png", ".webp", ".heic", ".heif"]);
+const VID = new Set([".mp4", ".mov", ".webm", ".m4v", ".avi", ".mkv", ".wmv"]);
+const SKIP_DIR = /^(porno|logo|inventory|test)$/i;
+const IMG_BUDGET = 24, VID_BUDGET = 16;
+const MAX_COVER = 2.8; // skip B-roll needing >2.8x upscale to fill the frame (would pixellate)
+
+const argv = process.argv.slice(2);
+const one = (f, d) => { const i = argv.indexOf(f); return i >= 0 && argv[i + 1] ? argv[i + 1] : d; };
+const many = (f) => { const o = []; for (let i = 0; i < argv.length; i++) if (argv[i] === f) { let j = i + 1; while (j < argv.length && !argv[j].startsWith("--")) o.push(argv[j++]); } return o; };
+const aroll = one("--aroll");
+const brollIn = many("--broll");
+const prompt = one("--prompt", "");
+const format = one("--format", "9x16");
+const styleRef = one("--style-ref", "");
+const captionStyleArg = one("--caption-style", "auto"); // "auto" → AI picks; override with e.g. "hormozi"
+const suggestIdx = one("--suggest", null);
+const swapArgs = many("--swap");
+const captionStyleSwapMode = argv.includes("--swap-caption-style");
+const out = path.resolve(one("--out", path.join(ENGINE, "out", "assembly.mp4")));
+const adjustMode = suggestIdx !== null || swapArgs.length >= 2 || captionStyleSwapMode;
+if (!aroll && !adjustMode) { console.error("ERROR: --aroll is required"); process.exit(1); }
+
+const isUrl = (s) => /^https?:\/\//i.test(s);
+const extOf = (f) => (isUrl(f) ? path.extname(new URL(f).pathname) : path.extname(f)).toLowerCase();
+const log = (...a) => console.error("[assemble]", ...a);
+const ff = (args) => execFileSync(FFMPEG, args, { stdio: ["ignore", "ignore", "ignore"] });
+async function download(url, dest) { const r = await fetch(url); if (!r.ok) throw new Error(`download ${r.status} ${url}`); fs.writeFileSync(dest, Buffer.from(await r.arrayBuffer())); }
+function evenSample(arr, n) { if (arr.length <= n) return arr.slice(); const step = arr.length / n, o = []; for (let i = 0; i < n; i++) o.push(arr[Math.floor(i * step)]); return o; }
+function probeDuration(file) { try { return parseFloat(execFileSync(FFPROBE, ["-v", "error", "-show_entries", "format=duration", "-of", "default=nw=1:nk=1", file]).toString().trim()) || 0; } catch { return 0; } }
+function probeDims(file) {
+  try {
+    const o = execFileSync(FFPROBE, ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "csv=p=0:s=x", file]).toString().trim();
+    const [w, h] = o.split("x").map(Number);
+    return [w || 0, h || 0];
+  } catch { return [0, 0]; }
+}
+function render() {
+  // pass the entry explicitly — when the engine lives inside another package (mcp/engine),
+  // Remotion would otherwise pick that package's src/index.ts as the entry.
+  const entry = path.join(ENGINE, "src", "index.ts");
+  // --public-dir: when nested in another package, Remotion picks the outer root's public/ by
+  // default; point it at the engine's own public/ so staticFile() assets resolve.
+  const r = spawnSync(`npx remotion render "${entry}" Assembly "${out}" "--props=${path.join(PUBLIC, "editData.json")}" "--public-dir=${PUBLIC}"`, { cwd: ENGINE, shell: true, stdio: "inherit" });
+  if (r.status !== 0) throw new Error(`remotion render failed (${r.status})`);
+}
+
+// prep dirs — skip destructive cleanup in swap/adjust modes so staged files survive
+if (!adjustMode) {
+  fs.rmSync(BROLL, { recursive: true, force: true });
+  fs.rmSync(path.join(PUBLIC, "aroll.mp4"), { force: true });
+}
+fs.mkdirSync(BROLL, { recursive: true });
+fs.mkdirSync(RUN, { recursive: true });
+fs.mkdirSync(CACHE, { recursive: true });
+fs.mkdirSync(path.dirname(out), { recursive: true });
+
+async function stageAroll() {
+  let src = aroll;
+  if (isUrl(aroll)) { src = path.join(RUN, "aroll_src"); await download(aroll, src); }
+  else if (!fs.existsSync(src)) throw new Error(`A-roll not found: ${src}`);
+  log("transcoding A-roll…");
+  ff(["-y", "-i", src, "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-movflags", "+faststart", path.join(PUBLIC, "aroll.mp4")]);
+}
+
+function listAlbums(dir) {
+  const albums = {};
+  const add = (name, fp) => {
+    const e = path.extname(fp).toLowerCase();
+    if (!IMG.has(e) && !VID.has(e)) return;
+    (albums[name] ??= { imgs: [], vids: [] })[IMG.has(e) ? "imgs" : "vids"].push(fp);
+  };
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) if (e.isFile()) add("(root)", path.join(dir, e.name));
+  for (const e of entries) if (e.isDirectory() && !SKIP_DIR.test(e.name)) {
+    const walk = (d) => fs.readdirSync(d, { withFileTypes: true }).forEach((x) => {
+      const fp = path.join(d, x.name);
+      if (x.isDirectory()) { if (!SKIP_DIR.test(x.name)) walk(fp); } else add(e.name, fp);
+    });
+    walk(path.join(dir, e.name));
+  }
+  return albums;
+}
+
+async function stageBroll(transcriptText, segments = []) {
+  const albums = {};
+  const merge = (name, v) => { albums[name] ??= { imgs: [], vids: [] }; albums[name].imgs.push(...v.imgs); albums[name].vids.push(...v.vids); };
+  const urls = [];
+  // Long-form videos queued for Twelve Labs temporal search (only when index is available).
+  const longFormQueue = [];
+  for (const p of brollIn) {
+    if (isUrl(p)) { urls.push(p); continue; }
+    const st = fs.statSync(p, { throwIfNoEntry: false });
+    if (!st) { log("skip (missing):", p); continue; }
+    if (st.isDirectory()) {
+      // Walk directory; intercept long videos.
+      const walked = listAlbums(p);
+      for (const [k, v] of Object.entries(walked)) {
+        const shortVids = [], longVids = [];
+        for (const vf of v.vids) {
+          if (EXPLAINER_INDEX_ID && TL_KEY && probeDuration(vf) > LONG_VIDEO_SECS) longVids.push(vf);
+          else shortVids.push(vf);
+        }
+        longFormQueue.push(...longVids);
+        merge(k, { imgs: v.imgs, vids: shortVids });
+      }
+    } else {
+      const e = extOf(p);
+      if (VID.has(e) && EXPLAINER_INDEX_ID && TL_KEY && probeDuration(p) > LONG_VIDEO_SECS) {
+        log(`long-form video (${probeDuration(p).toFixed(0)}s), queuing for Twelve Labs search: ${path.basename(p)}`);
+        longFormQueue.push(p);
+      } else {
+        merge("(loose)", { imgs: IMG.has(e) ? [p] : [], vids: VID.has(e) ? [p] : [] });
+      }
+    }
+  }
+  const names = Object.keys(albums);
+
+  // rank albums by name vs transcript
+  let weights = Object.fromEntries(names.map((n) => [n, 0.5]));
+  if (names.length > 1) {
+    try {
+      const r = await rankAlbums(transcriptText, names.map((n) => ({ name: n, count: albums[n].imgs.length + albums[n].vids.length })));
+      weights = r.weights;
+      log("album weights:", JSON.stringify(weights));
+    } catch (e) { log("album ranking failed (even weights):", e.message); }
+  }
+
+  const pick = (key, budget) => {
+    const avail = names.filter((n) => albums[n][key].length);
+    const sumW = avail.reduce((a, n) => a + (weights[n] ?? 0.3), 0) || 1;
+    let chosen = [];
+    for (const n of avail) chosen.push(...evenSample(albums[n][key], Math.max(1, Math.round(budget * (weights[n] ?? 0.3) / sumW))));
+    return evenSample(chosen, budget);
+  };
+  const files = [...pick("imgs", IMG_BUDGET), ...pick("vids", VID_BUDGET), ...urls];
+
+  const srcmap = {};
+  const keyOf = (f) => { try { const s = fs.statSync(f); return `${path.resolve(f)}|${s.size}|${Math.round(s.mtimeMs)}`; } catch { return `path:${f}`; } };
+  const [TW, TH] = format === "1x1" ? [1080, 1080] : format === "16x9" ? [1920, 1080] : [1080, 1920];
+  let img = 0, vid = 0;
+  for (const f of files) {
+    let src = f;
+    try {
+      if (isUrl(f)) { src = path.join(RUN, "dl_" + (img + vid)); await download(f, src); }
+      const [dw, dh] = probeDims(src);
+      if (dw && dh && Math.max(TW / dw, TH / dh) > MAX_COVER) { log("skip (low-res):", path.basename(String(f))); continue; }
+      let name;
+      if (VID.has(extOf(f))) {
+        name = `v${String(vid).padStart(2, "0")}.mp4`;
+        ff(["-y", "-i", src, "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-t", "6", "-vf", "scale='min(1280,iw)':-2", path.join(BROLL, name)]);
+        vid++;
+      } else {
+        name = `${String(img).padStart(2, "0")}.jpg`;
+        ff(["-y", "-i", src, "-vf", "scale='min(2048,iw)':-2", path.join(BROLL, name)]);
+        img++;
+      }
+      srcmap[name] = isUrl(f) ? `url:${f}` : keyOf(f);
+    } catch { log("skip (convert failed):", path.basename(String(f))); }
+  }
+  // Twelve Labs temporal search for long-form recordings.
+  if (longFormQueue.length > 0 && EXPLAINER_INDEX_ID && TL_KEY) {
+    log(`director pass: ${longFormQueue.length} long-form video(s) → Twelve Labs search (index: ${EXPLAINER_INDEX_ID})`);
+    const cache = readExplainerCache();
+    let decisions = [];
+    try { decisions = await getDirectorDecisions(segments); } catch { /* use transcript keywords as fallback */ }
+
+    if (decisions.length === 0) {
+      // Fallback: use the whole transcript as one search query.
+      decisions = [{ search_query: transcriptText.slice(0, 200), layout: "interrupt", first_mention_ms: 0 }];
+    }
+
+    for (const decision of decisions) {
+      log(`  searching: "${decision.search_query}"`);
+      const results = await tlSearch(decision.search_query, EXPLAINER_INDEX_ID);
+      if (!results.length) { log("  no results for:", decision.search_query); continue; }
+
+      const top = results[0];
+      const localPath = localPathFromVideoId(top.video_id, cache);
+      if (!localPath || !fs.existsSync(localPath)) {
+        log(`  video_id ${top.video_id} not found in local cache — re-run index_explainer_sources`);
+        continue;
+      }
+
+      const startSec = typeof top.start === "number" ? top.start : 0;
+      const endSec = typeof top.end === "number" ? top.end : startSec + 10;
+      const dur = Math.min(endSec - startSec, 30);
+      const clipName = `v${String(vid).padStart(2, "0")}.mp4`;
+      const clipPath = path.join(BROLL, clipName);
+      try {
+        ff(["-y", "-ss", String(startSec), "-t", String(dur), "-i", localPath,
+            "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac",
+            "-vf", "scale='min(1280,iw)':-2", clipPath]);
+        srcmap[clipName] = `tl:${top.video_id}:${startSec}`;
+        vid++;
+        log(`  ✓ extracted ${path.basename(localPath)} @ ${startSec.toFixed(1)}s-${(startSec + dur).toFixed(1)}s → ${clipName}`);
+      } catch (e) { log(`  ✗ clip extraction failed: ${e.message}`); }
+    }
+  }
+
+  fs.writeFileSync(path.join(RUN, "srcmap.json"), JSON.stringify(srcmap));
+  log(`B-roll: ${img} images + ${vid} videos staged (from ${names.length} albums${longFormQueue.length ? ` + ${longFormQueue.length} long-form via Twelve Labs` : ""})`);
+  return img + vid;
+}
+
+// analyze every staged B-roll (cached by source identity → index once)
+async function analyzeBroll() {
+  const srcmap = fs.existsSync(path.join(RUN, "srcmap.json")) ? JSON.parse(fs.readFileSync(path.join(RUN, "srcmap.json"))) : {};
+  const cacheFile = path.join(CACHE, "analysis.json");
+  const cache = fs.existsSync(cacheFile) ? JSON.parse(fs.readFileSync(cacheFile)) : {};
+  const res = {};
+  for (const name of fs.readdirSync(BROLL).sort()) {
+    const ext = path.extname(name).toLowerCase();
+    const kind = IMG.has(ext) ? "image" : VID.has(ext) ? "video" : null;
+    if (!kind) continue;
+    const key = srcmap[name];
+    if (key && cache[key]) { res[name] = cache[key]; log(`${name} (cached)`); continue; }
+    let frame = path.join(BROLL, name);
+    if (kind === "video") {
+      frame = path.join(RUN, "f_" + name + ".jpg");
+      const d = probeDuration(path.join(BROLL, name)) || 1;
+      try { ff(["-y", "-ss", String(Math.max(0.1, d / 2)), "-i", path.join(BROLL, name), "-frames:v", "1", "-vf", "scale=640:-1", frame]); } catch {}
+    }
+    try { res[name] = await analyzeFrame(frame, kind); if (key) cache[key] = res[name]; log(`${name} ${kind} ${res[name].subject} (${res[name].focal})`); }
+    catch (e) { res[name] = { kind, rotate: 0, focal: [0.5, 0.45], secondary: null, subject: "scenery", desc: "", keywords: [] }; log(`${name} analyze error: ${e.message}`); }
+  }
+  fs.writeFileSync(cacheFile, JSON.stringify(cache));
+  fs.writeFileSync(path.join(RUN, "analysis.json"), JSON.stringify(res, null, 2));
+  return res;
+}
+
+async function inferStyleFromRef(refPath) {
+  const [w, h] = probeDims(refPath); const dur = probeDuration(refPath);
+  const fmt = w === h ? "1x1" : w > h ? "16x9" : "9x16";
+  let cuts = 0;
+  try { const r = spawnSync(FFMPEG, ["-i", refPath, "-vf", "select='gt(scene,0.35)',showinfo", "-an", "-f", "null", "-"], { encoding: "utf8" }); cuts = (String(r.stderr).match(/showinfo/g) || []).length; } catch {}
+  const frames = [];
+  for (let i = 0; i < 8; i++) {
+    const t = dur ? Math.max(0.3, (dur * (i + 0.5)) / 8) : 1;
+    const fp = path.join(RUN, `sref_${i}.jpg`);
+    try { ff(["-y", "-ss", String(t), "-i", refPath, "-frames:v", "1", "-vf", "scale=320:-1", fp]); if (fs.existsSync(fp)) frames.push(fp); } catch {}
+  }
+  const style = await inferStyle(frames, { fmt, dur: Math.round(dur), cps: dur ? (cuts / dur).toFixed(2) : "0" });
+  log("inferred style:", JSON.stringify(style));
+  return style;
+}
+
+// ── adjustment modes ──────────────────────────────────────────────────
+function beatTextAt(transcript, fromF, durF, fps) {
+  const a = (fromF / fps) * 1000, b = ((fromF + durF) / fps) * 1000;
+  return transcript.filter((s) => (s.end_ms ?? 0) >= a && (s.start_ms ?? 0) <= b).map((s) => s.text).join(" ");
+}
+function rankCandidates(analysis, beat, usedFiles) {
+  const words = new Set(String(beat).toLowerCase().split(/\W+/).filter((w) => w.length > 3));
+  const scored = [];
+  for (const [name, a] of Object.entries(analysis)) {
+    if (usedFiles.has(name)) continue;
+    const kws = [...(a.keywords || []), ...String(a.desc || "").toLowerCase().split(/\W+/)];
+    let score = kws.reduce((s, k) => s + (words.has(String(k).toLowerCase()) ? 1 : 0), 0);
+    if (a.kind === "video") score += 0.5;
+    scored.push({ name, score, desc: a.desc, kind: a.kind });
+  }
+  return scored.sort((x, y) => y.score - x.score).slice(0, 6);
+}
+function suggestMode(idx) {
+  const editData = JSON.parse(fs.readFileSync(path.join(PUBLIC, "editData.json")));
+  const analysis = JSON.parse(fs.readFileSync(path.join(RUN, "analysis.json")));
+  const transcript = JSON.parse(fs.readFileSync(path.join(RUN, "transcript.json"))).segments || [];
+  const cut = editData.cuts[idx];
+  if (!cut) throw new Error(`no cut #${idx} (have ${editData.cuts.length})`);
+  const used = new Set(editData.cuts.map((c) => path.basename(c.file)));
+  const beat = beatTextAt(transcript, cut.from, cut.dur, editData.fps);
+  const sg = path.join(ENGINE, "suggest"); fs.rmSync(sg, { recursive: true, force: true }); fs.mkdirSync(sg, { recursive: true });
+  const options = [];
+  for (const t of rankCandidates(analysis, beat, used)) {
+    const thumb = path.join(sg, t.name.replace(/\.[^.]+$/, "") + ".jpg");
+    try { ff(["-y", "-ss", "0.5", "-i", path.join(BROLL, t.name), "-frames:v", "1", "-vf", "scale=240:-1", thumb]); } catch {}
+    options.push({ asset: t.name, kind: t.kind, desc: t.desc, thumb });
+  }
+  console.log("SUGGEST:" + JSON.stringify({ cut: idx, beat, current: path.basename(cut.file), options }));
+}
+function swapMode(idx, asset) {
+  const editData = JSON.parse(fs.readFileSync(path.join(PUBLIC, "editData.json")));
+  const analysis = JSON.parse(fs.readFileSync(path.join(RUN, "analysis.json")));
+  const a = analysis[asset]; if (!a) throw new Error(`unknown asset ${asset}`);
+  const cut = editData.cuts[idx]; if (!cut) throw new Error(`no cut #${idx}`);
+  const [w, h] = probeDims(path.join(BROLL, asset));
+  Object.assign(cut, { file: "broll/" + asset, focal: a.focal, secondary: a.secondary || null, video: a.kind === "video", srcW: w, srcH: h });
+  fs.writeFileSync(path.join(PUBLIC, "editData.json"), JSON.stringify(editData, null, 2));
+  render();
+  console.log("RESULT:" + out);
+}
+
+function swapCaptionStyleMode(styleId) {
+  const VALID = ["default", "hormozi", "glow_neon", "minimalist", "whiteboard"];
+  if (!VALID.includes(styleId)) throw new Error(`unknown caption style "${styleId}". Choose one of: ${VALID.join(", ")}`);
+  const editData = JSON.parse(fs.readFileSync(path.join(PUBLIC, "editData.json")));
+  editData.captionStyle = styleId;
+  fs.writeFileSync(path.join(PUBLIC, "editData.json"), JSON.stringify(editData, null, 2));
+  log(`caption style swapped to: ${styleId}`);
+  render();
+  console.log("RESULT:" + out);
+}
+
+async function main() {
+  if (suggestIdx !== null) return suggestMode(parseInt(suggestIdx, 10));
+  if (swapArgs.length >= 2) return swapMode(parseInt(swapArgs[0], 10), swapArgs[1]);
+  if (captionStyleSwapMode) return swapCaptionStyleMode(captionStyleArg !== "auto" ? captionStyleArg : "default");
+
+  await stageAroll();
+  const dur = probeDuration(path.join(PUBLIC, "aroll.mp4"));
+  const fps = 30, totalFrames = Math.max(1, Math.round(dur * fps)), totalMs = Math.round(dur * 1000);
+  log(`A-roll ${dur.toFixed(2)}s → ${totalFrames} frames`);
+
+  // transcribe
+  log("transcribing (Gemini)…");
+  ff(["-y", "-i", path.join(PUBLIC, "aroll.mp4"), "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", path.join(RUN, "aroll.wav")]);
+  const segments = await transcribe(path.join(RUN, "aroll.wav"));
+  fs.writeFileSync(path.join(RUN, "transcript.json"), JSON.stringify({ segments }, null, 2));
+  const transcriptText = segments.map((s) => s.text).join(" ");
+  log(`transcript: ${segments.length} segments`);
+
+  // style
+  let style = null;
+  if (styleRef) {
+    log("inferring style from reference…");
+    let sref = styleRef;
+    if (isUrl(styleRef)) { sref = path.join(RUN, "styleref"); await download(styleRef, sref); }
+    try { style = await inferStyleFromRef(sref); } catch (e) { log("style inference failed (defaults):", e.message); }
+  }
+  const effFormat = style?.format || format;
+  const wantCaptions = !style || style.captions !== false;
+
+  // caption style — user override > style_ref inference > AI transcript analysis
+  let captionStyle = "default";
+  if (captionStyleArg && captionStyleArg !== "auto") {
+    captionStyle = captionStyleArg;
+    log(`caption style: ${captionStyle} (user-specified)`);
+  } else if (style?.caption_style) {
+    captionStyle = style.caption_style;
+    log(`caption style: ${captionStyle} (inferred from style_ref)`);
+  } else {
+    log("inferring caption style from transcript…");
+    try { captionStyle = await inferCaptionStyle(transcriptText); } catch { captionStyle = "default"; }
+    log(`caption style: ${captionStyle} (AI-inferred)`);
+  }
+
+  const nBroll = await stageBroll(transcriptText, segments);
+
+  let cuts = [], pops = [], hook = null, analysis = {};
+  if (nBroll > 0) {
+    log("analysing B-roll (Gemini vision)…");
+    analysis = await analyzeBroll();
+    // correct sideways B-roll
+    for (const [name, a] of Object.entries(analysis)) {
+      const rot = a.rotate || 0;
+      if (rot !== 90 && rot !== 180 && rot !== 270) continue;
+      const file = path.join(BROLL, name);
+      const isVid = name.toLowerCase().endsWith(".mp4");
+      const tmp = file + (isVid ? ".rot.mp4" : ".rot.jpg");
+      const tp = rot === 90 ? "transpose=1" : rot === 270 ? "transpose=2" : "transpose=1,transpose=1";
+      try { ff(["-y", "-i", file, "-vf", tp, ...(isVid ? ["-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac"] : []), tmp]); fs.renameSync(tmp, file); log(`rotated ${name} ${rot}°`); } catch { log("rotate failed:", name); }
+    }
+    log("editorial pass (Gemini)…");
+    const edit = await editTimeline(segments, analysis, totalMs, prompt, style);
+    cuts = edit.cuts; pops = edit.pops; hook = edit.hook;
+  }
+
+  // captions
+  const capsMs = [];
+  for (const s of (wantCaptions ? segments : [])) {
+    const raw = String(s.text || "").trim();
+    if (/^\(.*\)$/.test(raw)) continue;
+    const words = raw.split(/\s+/).filter(Boolean);
+    if (!words.length) continue;
+    const span = Math.max(600, (s.end_ms || 0) - (s.start_ms || 0));
+    const chunks = []; for (let i = 0; i < words.length; i += 3) chunks.push(words.slice(i, i + 3).join(" "));
+    const totChars = chunks.reduce((a, c) => a + c.length, 0) || 1;
+    let t = s.start_ms || 0;
+    for (const c of chunks) { const d = Math.max(380, Math.round(span * (c.length / totChars))); capsMs.push({ from_ms: t, dur_ms: d, text: c }); t += d; }
+  }
+
+  // build editData
+  const f2 = (ms) => Math.round((ms / 1000) * fps);
+  let built = [];
+  for (const c of cuts) {
+    const a = analysis[c.broll_id]; if (!a) continue;
+    const from = Math.max(0, f2(c.from_ms)), d = Math.max(8, f2(c.dur_ms));
+    if (from + d > totalFrames) continue;
+    const [srcW, srcH] = probeDims(path.join(BROLL, c.broll_id));
+    built.push({ from, dur: d, file: "broll/" + c.broll_id, video: a.kind === "video", dir: c.dir ? 1 : 0, focal: a.focal, secondary: a.secondary || null, srcW, srcH });
+  }
+  built.sort((x, y) => x.from - y.from);
+  const cleaned = []; let last = -1;
+  for (const c of built) if (c.from >= last) { cleaned.push(c); last = c.from + c.dur; }
+
+  const popsF = pops.map((p) => ({ from: f2(p.from_ms), dur: 27, text: String(p.text).toUpperCase() })).filter((p) => p.from >= 0 && p.from + p.dur <= totalFrames);
+
+  const AROLL_FY = 0.38;
+  const captionY = (from, durF) => {
+    const mid = from + durF / 2;
+    const cut = cleaned.find((c) => mid >= c.from && mid < c.from + c.dur);
+    const focalY = cut ? cut.focal[1] : AROLL_FY;
+    let y = 0.58;
+    if (Math.abs(focalY - y) < 0.16) y = focalY < 0.5 ? Math.min(0.82, focalY + 0.3) : Math.max(0.2, focalY - 0.3);
+    if (popsF.some((p) => mid >= p.from - 4 && mid < p.from + p.dur + 4)) y = 0.84;
+    return Math.max(0.16, Math.min(0.86, y));
+  };
+  const captions = capsMs
+    .map((c) => ({ from: f2(c.from_ms), dur: Math.max(8, f2(c.dur_ms)), text: c.text }))
+    .filter((c) => c.from < totalFrames)
+    .map((c) => { const durF = Math.min(c.dur, totalFrames - c.from); return { ...c, dur: durF, y: captionY(c.from, durF) }; });
+  const hookF = hook && hook.text ? { from: 0, dur: Math.min(110, totalFrames), text: hook.text, keyword: hook.keyword || "" } : null;
+
+  const editData = { format: effFormat, fps, totalFrames, aroll: "aroll.mp4", arollFocal: [0.5, 0.38], cuts: cleaned, captions, pops: popsF, hook: hookF, captionStyle };
+  fs.writeFileSync(path.join(PUBLIC, "editData.json"), JSON.stringify(editData, null, 2));
+  log(`${cleaned.length} cutaways, ${captions.length} captions, ${popsF.length} pops, hook=${hookF ? "yes" : "no"}, captionStyle=${captionStyle} → rendering…`);
+  render();
+  console.log("RESULT:" + out);
+}
+main().catch((e) => { console.error("[assemble] FATAL:", e.message); process.exit(1); });

package/engine/gemini.mjs

@@ -0,0 +1,164 @@
+// Node port of the Python Gemini scripts (_gem/transcribe/analyze/edit/style/albums) so the
+// engine needs only Node — no Python. All calls are Gemini REST (generateContent), thinking off.
+import fs from "node:fs";
+import path from "node:path";
+import { prompt as storedPrompt, fill } from "./prompts.mjs";
+
+const MODEL = "gemini-2.5-flash";
+
+function getKey() {
+  if (process.env.VITE_GEMINI_API_KEY) return process.env.VITE_GEMINI_API_KEY;
+  if (process.env.GEMINI_API_KEY) return process.env.GEMINI_API_KEY;
+  // local fallback: parse a .env (the repo's, or VIRALSPIN_ENV)
+  for (const env of [process.env.VIRALSPIN_ENV, "E:/AI test/github/viralspin_new/.env"]) {
+    if (env && fs.existsSync(env)) {
+      for (const ln of fs.readFileSync(env, "utf8").split(/\r?\n/)) {
+        if (ln.trim().startsWith("VITE_GEMINI_API_KEY")) return ln.split("=").slice(1).join("=").trim().replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+  throw new Error("No Gemini API key (set GEMINI_API_KEY or VITE_GEMINI_API_KEY).");
+}
+const KEY = getKey();
+const URL = `https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent?key=${KEY}`;
+
+const mimeOf = (p) => {
+  const e = path.extname(p).toLowerCase();
+  return e === ".png" ? "image/png" : e === ".wav" ? "audio/wav" : e === ".mp3" ? "audio/mpeg" : "image/jpeg";
+};
+export const inlinePart = (p) => ({ inline_data: { mime_type: mimeOf(p), data: fs.readFileSync(p).toString("base64") } });
+
+export async function call(parts, maxTokens = 600) {
+  const body = {
+    contents: [{ parts }],
+    generationConfig: { temperature: 0.2, maxOutputTokens: maxTokens, thinkingConfig: { thinkingBudget: 0 }, responseMimeType: "application/json" },
+  };
+  const r = await fetch(URL, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  const resp = await r.json();
+  const cand = resp?.candidates?.[0];
+  const txt = (cand?.content?.parts || []).map((p) => p.text || "").join("");
+  if (!txt.trim()) throw new Error(`empty Gemini response (finish=${cand?.finishReason} status=${r.status})`);
+  const m = txt.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+  return JSON.parse(m ? m[0] : txt);
+}
+
+export async function transcribe(wavPath) {
+  const d = await call([inlinePart(wavPath), { text: storedPrompt("local_assembly.transcribe") }], 1200);
+  return d.segments || (Array.isArray(d) ? d : []);
+}
+
+export async function analyzeFrame(jpgPath, kind) {
+  const d = await call([inlinePart(jpgPath), { text: storedPrompt("local_assembly.frame_analysis") }], 300);
+  const sx = d.secondary_x, sy = d.secondary_y;
+  return {
+    kind,
+    rotate: parseInt(d.rotate || 0, 10) || 0,
+    focal: [+(+d.focal_x || 0.5).toFixed(4), +(+d.focal_y || 0.45).toFixed(4)],
+    secondary: sx != null && sy != null ? [+(+sx).toFixed(4), +(+sy).toFixed(4)] : null,
+    subject: d.subject || "scenery",
+    desc: d.desc || "",
+    keywords: d.keywords || [],
+  };
+}
+
+export async function rankAlbums(transcriptText, folders) {
+  const prompt = fill(storedPrompt("local_assembly.album_ranking"), {
+    transcript_text: transcriptText,
+    albums_json: JSON.stringify(folders),
+  });
+  try {
+    const d = await call([{ text: prompt }], 700);
+    const w = {}; for (const [k, v] of Object.entries(d.weights || {})) w[k] = +v;
+    return { weights: w, note: d.note || "" };
+  } catch {
+    return { weights: Object.fromEntries(folders.map((f) => [f.name, 0.5])), note: "(fallback)" };
+  }
+}
+
+const VALID_CAPTION_STYLES = ["default", "hormozi", "glow_neon", "minimalist", "whiteboard"];
+
+export async function inferStyle(framePaths, meta) {
+  const prompt = fill(storedPrompt("local_assembly.style_inference"), {
+    frame_count: framePaths.length,
+    format: meta.fmt,
+    duration: meta.dur,
+    cuts_per_sec: meta.cps,
+  });
+  const d = await call([...framePaths.map(inlinePart), { text: prompt }], 400);
+  return {
+    format: meta.fmt,
+    captions: d.captions !== false,
+    hook: d.hook !== false,
+    pops: d.pops !== false,
+    pace: d.pace || "fast",
+    coverage: +(d.coverage ?? 0.5) || 0.5,
+    caption_style: VALID_CAPTION_STYLES.includes(d.caption_style) ? d.caption_style : null,
+    note: d.note || "",
+  };
+}
+
+// Infer caption style from transcript tone when no style_ref is available.
+export async function inferCaptionStyle(transcriptText) {
+  const prompt = `You are a social video editor. Given this A-roll transcript, pick the best caption style for a short-form social video.
+
+Styles:
+- "hormozi": high-energy, motivational, business/hustle content, talking-head, bold claims
+- "glow_neon": dark aesthetic, music, nightlife, gaming, cyberpunk, late-night vibes
+- "minimalist": calm, educational, soft aesthetic, wellness, thoughtful narration
+- "whiteboard": explainer, how-to, tutorial, step-by-step, educational breakdown
+- "default": neutral, general purpose, anything else
+
+Transcript: ${transcriptText.slice(0, 2000)}
+
+Return JSON: {"caption_style": "<one of the five options>", "reason": "<one sentence>"}`;
+  try {
+    const d = await call([{ text: prompt }], 200);
+    return VALID_CAPTION_STYLES.includes(d.caption_style) ? d.caption_style : "default";
+  } catch {
+    return "default";
+  }
+}
+
+export async function getDirectorDecisions(transcriptSegments) {
+  if (!transcriptSegments || transcriptSegments.length === 0) return [];
+  const transcriptText = transcriptSegments.map((s) => s.text || "").join(" ");
+  const prompt = `Analyze this A-roll transcript. Extract entities that a viewer would expect to SEE visualized on screen — named people, specific products, UI tools, app interfaces, or branded concepts.
+
+For each entity return:
+- name: entity name
+- search_query: a 5-10 word Twelve Labs video search query (e.g. "Jensen Huang talking about Blackwell GPU")
+- layout: "pip" if it is a named person (keep the speaker visible alongside them), "interrupt" if it is a product/UI/demo (full-screen cutaway)
+- first_mention_ms: estimated millisecond offset of the first mention (base on word position in transcript)
+
+Transcript: ${transcriptText.slice(0, 3000)}
+
+Return JSON: {"entities": [{"name": "...", "search_query": "...", "layout": "pip", "first_mention_ms": 0}]}`;
+  try {
+    const d = await call([{ text: prompt }], 800);
+    return (d.entities || []).filter((e) => e.name && e.search_query);
+  } catch (err) {
+    return [];
+  }
+}
+
+export async function editTimeline(transcript, analysis, totalMs, userPrompt, style) {
+  const pace = style?.pace || "fast";
+  const PACE = {
+    fast: "Energetic: short cutaways 600-1100 ms and a 3-4 shot montage on numbers/claims. RELEVANCE WINS over coverage — only cut where a clip genuinely fits; otherwise stay on the speaker. Do NOT chase a coverage %.",
+    medium: "Cutaways 1000-1800 ms, only where a clip genuinely fits; otherwise stay on the speaker.",
+    slow: "Few, longer cutaways 1800-3000 ms; relevance first.",
+  }[pace] || "";
+  const incHook = style ? style.hook !== false : true;
+  const incPops = style ? style.pops !== false : true;
+  const candidates = Object.entries(analysis).map(([id, a]) => ({ id, kind: a.kind, subject: a.subject, desc: a.desc, keywords: a.keywords }));
+  const sys = fill(storedPrompt("local_assembly.timeline_edit"), {
+    pacing: PACE,
+    transcript_json: JSON.stringify(transcript),
+    candidates_json: JSON.stringify(candidates),
+    total_ms: totalMs,
+    user_direction: userPrompt || "(none)",
+  });
+  const d = await call([{ text: sys }], 2000);
+  const cuts = (d.cuts || []).filter((c) => analysis[c.broll_id]).sort((a, b) => (a.from_ms || 0) - (b.from_ms || 0));
+  return { cuts, pops: incPops ? (d.pops || []).filter((p) => p.text) : [], hook: incHook ? d.hook || null : null };
+}