@crievo/omni 0.0.0-stage → 0.1.0

package/tools/compose.mjs

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Parallel composition (stage 3): the base first, then one fork per scene, all
+   at once.
+
+     node tools/compose.mjs plan videos/<slug> [--all] [--json]
+         which scenes to compose, how many at a time, the model and effort, and
+         the prompt of each fork. `--all` recomposes the scenes already
+         composed too (reference swap). It refuses while the base is missing
+         (av-motion `base da composição`: the style in shared code, in
+         motion/src/_common.html, and the "Base da composição" section of
+         motion.md).
+     node tools/compose.mjs apply videos/<slug> cNN
+         merges the scene's plan into scenes.json and motion.md, under a lock.
+
+   Each scene is handed out once (tools/lib/fanout.mjs): a second `plan` lists
+   the scenes still running as busy and launches nothing, and each fork starts
+   with `fanout.mjs claim … compose cNN --run R`, which refuses a scene that is
+   someone else's. That is what keeps a scene from being composed twice at the
+   same time (2026-10-17: two sets of forks for the same scenes).
+
+   Each scene fork writes only files of its own:
+
+     motion/src/<id>.html            the scene
+     motion/src/_common.<id>.html    optional: what it adds to the shared code
+                                     (build-motion pastes it after _common.html)
+     motion/plan/<id>.json           { min_duration, beats, transition?, lead_in?,
+                                       hold?, missing_sounds? }
+     motion/plan/<id>.md             the composition notes (no heading)
+
+   and then calls `apply`, which is the only writer of scenes.json and motion.md
+   during the composition: two forks editing the same file at the same time
+   lose each other's edit. In scenes.json, `apply` sets only the plan's keys (a
+   `null` removes one) and keeps each beat's `enters_with` when the element
+   keeps its name. In motion.md, it keeps one block per scene, between
+   <!-- omnivideo:composition <id> --> markers, in the "Composição por cena"
+   section, in scene order.
+
+   Why forks through the Agent tool: forked skills called in the same message
+   run one after the other (measured on 2026-10-17, Claude Code 2.1.296: 20 s +
+   20 s); Agent calls in the same message run together, also in `claude -p`.
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { join, resolve, relative } from "node:path";
+import { plan as fanout, agentModel, waves as split, printPlan, withScenesLock } from "./lib/fanout.mjs";
+import { DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const STEP = 0.6;
+const PLAN_KEYS = ["min_duration", "beats", "transition", "lead_in", "hold"];
+const SECTION = "## Composição por cena";
+
+const [cmd, target, ...rest] = process.argv.slice(2);
+const flag = n => rest.includes(`--${n}`);
+const usage = () => {
+  console.error(
+    "uso: node tools/compose.mjs plan videos/<slug> [--all] [--json]\n" +
+      "     node tools/compose.mjs apply videos/<slug> cNN",
+  );
+  process.exit(2);
+};
+if (!target) usage();
+const dir = resolve(target);
+if (!existsSync(join(dir, "scenes.json"))) {
+  console.error(`erro: falta ${join(dir, "scenes.json")}`);
+  process.exit(2);
+}
+const readScenes = () => JSON.parse(readFileSync(join(dir, "scenes.json"), "utf8"));
+
+/* ---------- plan ---------------------------------------------------------- */
+
+function composed(scene) {
+  return (
+    scene.min_duration != null &&
+    scene.beats?.length > 0 &&
+    existsSync(join(dir, "motion", "src", `${scene.id}.html`)) &&
+    existsSync(join(dir, "motion", "stills", `${scene.id}.png`))
+  );
+}
+
+/* the base: the style in shared code, written once before the scenes (av-motion
+   `base da composição`). A video composed with a preview has its "Aprovado na
+   prévia" section instead, which counts the same */
+function hasBase() {
+  const md = existsSync(join(dir, "motion.md")) ? readFileSync(join(dir, "motion.md"), "utf8") : "";
+  return (
+    existsSync(join(dir, "motion", "src", "_common.html")) && /\n## (Base da composição|Aprovado na prévia)/.test(md)
+  );
+}
+
+async function plan() {
+  const video = readScenes();
+  const stage = CFG.models?.stages?.["av-motion"] ?? { model: "opus", effort: "high" };
+  const parallel = Math.max(1, CFG.motion?.compose?.parallel ?? 8);
+  const slug = relative(ROOT, dir);
+  if (!hasBase()) {
+    console.error(
+      `erro: falta a base da composição (motion/src/_common.html e a seção "Base da composição" do motion.md). ` +
+        `Antes das cenas: av-motion com "${slug} base da composição".`,
+    );
+    process.exit(1);
+  }
+  const wanted = [],
+    done = [];
+  for (const s of video.scenes) (flag("all") || !composed(s) ? wanted : done).push(s.id);
+  const {
+    run,
+    planned,
+    busy: held,
+  } = wanted.length ? await fanout(dir, "compose", wanted) : { run: null, planned: [], busy: [] };
+  const ws = split(planned, parallel);
+  const prompt = id =>
+    `Você é um fork da skill av-motion. Leia .claude/skills/av-motion/SKILL.md e siga-a ` +
+    `com este pedido: ${slug} compor ${id} (paralelo, rodada ${run}). Termine com o relatório curto que a skill pede.`;
+  const out = {
+    video: slug,
+    run,
+    model: agentModel(stage.model),
+    effort: stage.effort ?? "high",
+    parallel,
+    done,
+    busy: held,
+    waves: ws.map(w => w.map(id => ({ scene: id, description: `compor ${id}`, prompt: prompt(id) }))),
+  };
+  if (flag("json")) {
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+  if (!wanted.length) {
+    console.log(`nada a compor: ${done.length ? `já compostas ${done.join(" ")}` : "sem cenas"}`);
+    console.log(`próximo: ${slug} fechar composição`);
+    return;
+  }
+  printPlan({
+    title:
+      `composição em paralelo · ${planned.length} cena(s) nesta rodada · até ${parallel} por vez · ` +
+      `modelo ${out.model}, esforço ${out.effort}` +
+      (done.length ? `\njá compostas: ${done.join(" ")}` : ""),
+    run,
+    waves: ws,
+    model: out.model,
+    effort: out.effort,
+    prompt,
+    busy: held,
+    after: `Depois da última onda: ${slug} fechar composição (skill av-motion, uma chamada).`,
+  });
+  if (!run)
+    console.log(
+      `\nnada novo a lançar: as cenas acima já têm fork. Espere os relatórios; um fork que morreu ` +
+        `(erro, sem relatório) se libera com fanout.mjs release ${slug} compose cNN e volta no próximo plan.`,
+    );
+}
+
+/* ---------- apply --------------------------------------------------------- */
+
+function writeAtomic(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+}
+
+const offGrid = x => Math.abs(x / STEP - Math.round(x / STEP)) > 1e-6;
+
+function validate(scene, isFirst, p) {
+  const errors = [],
+    warnings = [];
+  if (p.min_duration != null) {
+    if (typeof p.min_duration !== "number" || p.min_duration <= 0) errors.push("min_duration inválido");
+    else if (offGrid(p.min_duration)) warnings.push(`min_duration ${p.min_duration} não é múltiplo de ${STEP}`);
+  }
+  if (p.beats != null) {
+    if (!Array.isArray(p.beats) || !p.beats.length) errors.push("beats precisa ser uma lista não vazia");
+    else {
+      const names = new Set();
+      for (const b of p.beats) {
+        if (!b?.element) errors.push(`beat sem element: ${JSON.stringify(b)}`);
+        else if (names.has(b.element)) errors.push(`beat repetido: ${b.element}`);
+        else names.add(b.element);
+        if (typeof b?.t !== "number") errors.push(`beat ${b?.element}: t precisa ser número`);
+        else {
+          if (offGrid(b.t)) warnings.push(`beat ${b.element}: t ${b.t} não é múltiplo de ${STEP}`);
+          if (p.min_duration != null && b.t > p.min_duration) warnings.push(`beat ${b.element} depois do min_duration`);
+        }
+      }
+    }
+  }
+  const tr = p.transition;
+  if (tr != null) {
+    if (isFirst) warnings.push("transition na primeira cena é ignorada");
+    const ok =
+      tr === "cut" ||
+      (typeof tr === "object" &&
+        (tr.continues == null || (Array.isArray(tr.continues) && tr.continues.length)) &&
+        (tr.continues != null || tr.sound != null));
+    if (!ok)
+      errors.push(`transition inválida: ${JSON.stringify(tr)}; use "cut", { "continues": [...] } ou { "sound": ... }`);
+  }
+  for (const k of ["lead_in", "hold"])
+    if (p[k] != null && (typeof p[k] !== "number" || p[k] < 0)) errors.push(`${k} inválido`);
+  return { errors, warnings };
+}
+
+function mergeScene(scene, p) {
+  for (const k of PLAN_KEYS) {
+    if (!(k in p)) continue;
+    if (p[k] === null) {
+      delete scene[k];
+      continue;
+    }
+    if (k === "beats") {
+      /* narration already tied these beats to words: a beat that keeps its name keeps the tie */
+      const tied = Object.fromEntries(
+        (scene.beats ?? []).filter(b => b.enters_with != null).map(b => [b.element, b.enters_with]),
+      );
+      scene.beats = p.beats.map(b =>
+        tied[b.element] != null && b.enters_with == null ? { ...b, enters_with: tied[b.element] } : b,
+      );
+    } else scene[k] = p[k];
+  }
+}
+
+/* motion.md: one marked block per scene, in the "Composição por cena" section */
+function mergeNotes(md, video, scene, notes) {
+  const open = id => `<!-- omnivideo:composition ${id} -->`;
+  const close = id => `<!-- /omnivideo:composition ${id} -->`;
+  const block = `${open(scene.id)}\n### ${scene.id} · ${scene.title ?? ""}\n\n${notes.trim()}\n${close(scene.id)}`;
+
+  let start = md.indexOf(`\n${SECTION}`);
+  if (start < 0) {
+    /* before Passagens (or a legacy preview section), so the scene notes stay together */
+    const anchor = ["\n## Passagens", "\n## Aprovado na prévia"].map(h => md.indexOf(h)).find(i => i >= 0);
+    const section = `\n${SECTION}\n\nBeats, duração, passagem e sons de cada cena (etapa 3), uma por chamada.\n\n`;
+    md =
+      anchor == null
+        ? `${md.trimEnd()}\n\n---\n${section}`
+        : `${md.slice(0, anchor)}${section}---\n${md.slice(anchor)}`;
+    start = md.indexOf(`\n${SECTION}`);
+  }
+  const bodyStart = md.indexOf("\n", start + 1) + 1;
+  const next = md.slice(bodyStart).search(/\n## /);
+  const bodyEnd = next < 0 ? md.length : bodyStart + next + 1;
+  let body = md.slice(bodyStart, bodyEnd);
+
+  const blocks = {};
+  for (const s of video.scenes) {
+    const re = new RegExp(`${open(s.id)}[\\s\\S]*?${close(s.id)}\\n?`);
+    const m = body.match(re);
+    if (m) {
+      blocks[s.id] = m[0].trimEnd();
+      body = body.replace(re, "");
+    }
+  }
+  blocks[scene.id] = block;
+  /* what is left: the section's intro and the separator before the next heading */
+  const trailingRule = /\n-{3,}\s*$/.test(body);
+  const intro = body.replace(/\n-{3,}\s*$/, "").trim();
+  const ordered = video.scenes.filter(s => blocks[s.id]).map(s => blocks[s.id]);
+  const rebuilt = `\n${intro ? `${intro}\n\n` : ""}${ordered.join("\n\n")}\n\n${trailingRule ? "---\n" : ""}`;
+  return md.slice(0, bodyStart) + rebuilt + md.slice(bodyEnd);
+}
+
+async function apply() {
+  const id = rest[0];
+  if (!id) usage();
+  const planFile = join(dir, "motion", "plan", `${id}.json`);
+  const notesFile = join(dir, "motion", "plan", `${id}.md`);
+  if (!existsSync(planFile)) {
+    console.error(`erro: falta ${relative(ROOT, planFile)}`);
+    process.exit(1);
+  }
+  let p;
+  try {
+    p = JSON.parse(readFileSync(planFile, "utf8"));
+  } catch (e) {
+    console.error(`erro: ${relative(ROOT, planFile)} não é JSON válido: ${e.message}`);
+    process.exit(1);
+  }
+  await withScenesLock(dir, () => {
+    const video = readScenes();
+    const index = video.scenes.findIndex(s => s.id === id);
+    if (index < 0) throw new Error(`${id} não existe em scenes.json`);
+    const scene = video.scenes[index];
+    const { errors, warnings } = validate(scene, index === 0, p);
+    if (errors.length) throw new Error(errors.map(e => `${id}: ${e}`).join("\nerro: "));
+    mergeScene(scene, p);
+    writeAtomic(join(dir, "scenes.json"), JSON.stringify(video, null, 2) + "\n");
+    const mdFile = join(dir, "motion.md");
+    if (existsSync(notesFile) && existsSync(mdFile))
+      writeAtomic(mdFile, mergeNotes(readFileSync(mdFile, "utf8"), video, scene, readFileSync(notesFile, "utf8")));
+    else if (!existsSync(notesFile)) warnings.push(`sem ${relative(ROOT, notesFile)}: motion.md não recebeu as notas`);
+    const keys = PLAN_KEYS.filter(k => k in p);
+    console.log(`${id} · ${keys.join(", ")} → scenes.json${existsSync(notesFile) ? " · notas → motion.md" : ""}`);
+    warnings.forEach(w => console.log(`aviso: ${id}: ${w}`));
+    for (const m of p.missing_sounds ?? [])
+      console.log(
+        `aviso: ${id}: som fora do kit para capturar no fechamento: ${typeof m === "string" ? m : JSON.stringify(m)}`,
+      );
+  });
+}
+
+if (cmd === "plan" || cmd === "apply")
+  await (cmd === "plan" ? plan() : apply()).catch(e => {
+    console.error(`erro: ${e.message}`);
+    process.exit(1);
+  });
+else usage();

package/tools/cuts.mjs

@@ -0,0 +1,74 @@
+/* ============================================================================
+   Editor range cuts (studio Editor stage): parts of the video that leave the
+   export, without redoing voice, render or sound.
+
+   `cuts` at the root of scenes.json: [{ from, to }], in seconds of
+   scenes.json time (the whole video, with no cuts). Everything inside a cut
+   (scene, line, effect, bed, caption) disappears from the export; whatever
+   starts before or ends after loses only the inside part. assemble.mjs applies
+   the cuts last, over the already assembled image and sound, and what comes
+   after moves back (closes the gap).
+
+   Two timelines: scenes.json's ("original") and the export's ("edited").
+   toEdited and toOriginal convert between them. The studio screen uses this
+   same file.
+   ============================================================================ */
+
+const EPS = 1e-6;
+
+/* sort, merge the ones that touch, snap to the frame and clamp inside the
+   video; anything shorter than one frame is dropped */
+export function normalizeCuts(cuts, total, fps) {
+  const q = s => Math.round(s * fps) / fps;
+  const list = (Array.isArray(cuts) ? cuts : [])
+    .map(c => ({
+      from: q(Math.max(0, Math.min(total, Number(c?.from)))),
+      to: q(Math.max(0, Math.min(total, Number(c?.to)))),
+    }))
+    .filter(c => Number.isFinite(c.from) && Number.isFinite(c.to) && c.to - c.from >= 1 / fps - EPS)
+    .sort((a, b) => a.from - b.from);
+  const merged = [];
+  for (const c of list) {
+    const last = merged.at(-1);
+    if (last && c.from <= last.to + EPS) last.to = Math.max(last.to, c.to);
+    else merged.push({ ...c });
+  }
+  return merged.map(c => ({ from: +c.from.toFixed(4), to: +c.to.toFixed(4) }));
+}
+
+export const removedDuration = cuts => cuts.reduce((s, c) => s + (c.to - c.from), 0);
+
+/* the segments that stay, in original time: [[from, to], …] */
+export function keptSegments(cuts, total) {
+  const segs = [];
+  let cursor = 0;
+  for (const c of cuts) {
+    if (c.from > cursor + EPS) segs.push([cursor, c.from]);
+    cursor = Math.max(cursor, c.to);
+  }
+  if (total > cursor + EPS) segs.push([cursor, total]);
+  return segs;
+}
+
+/* original → edited; an instant inside a cut lands on the cut point */
+export function toEdited(t, cuts) {
+  let before = 0;
+  for (const c of cuts) {
+    if (t <= c.from) break;
+    before += Math.min(t, c.to) - c.from;
+  }
+  return t - before;
+}
+
+/* edited → original; at a cut point, goes to after it (that is what plays) */
+export function toOriginal(t, cuts) {
+  let o = t;
+  for (const c of cuts) {
+    if (c.from <= o + EPS) o += c.to - c.from;
+    else break;
+  }
+  return o;
+}
+
+/* strictly inside some cut */
+export const isCut = (t, cuts) => cuts.some(c => t > c.from + EPS && t < c.to - EPS);