@crievo/omni 0.0.0-stage → 0.1.1

package/tools/approval.mjs

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Approval in the UI, in rounds: the scenes of the motion script (one by one)
+   and the content script (whole). The user approves or requests a change; on
+   the script, they may also edit the text themselves. If nobody touches it,
+   the round approves itself at the deadline (`motion.approval.auto_approve_min`
+   for the scenes and `script.approval.auto_approve_min` for the script, in the
+   config; 10 min). While the user edits, the countdown pauses; when they
+   confirm (or cancel), it resumes where it stopped.
+
+     node tools/approval.mjs open    videos/<slug> [--all] [--reopen c02,c03]
+     node tools/approval.mjs wait    videos/<slug>
+     node tools/approval.mjs show    videos/<slug>
+     node tools/approval.mjs decide  videos/<slug> c02 approve|change ["what to change"]
+     node tools/approval.mjs approve-all videos/<slug>
+     node tools/approval.mjs pause   videos/<slug>
+     node tools/approval.mjs resume  videos/<slug>
+
+   With --script, the same commands apply to the script; in decide, the id is
+   `script` (and --script is implied):
+
+     node tools/approval.mjs open   videos/<slug> --script
+     node tools/approval.mjs wait   videos/<slug> --script
+     node tools/approval.mjs decide videos/<slug> script change "o gancho mais curto"
+
+   open      after the motion script (or after adjusting scenes): opens the
+             round with a new deadline. An approved scene stays approved; one
+             that requested a change, a new one and those in --reopen go back
+             to pending; --all resets everything. The script always goes back
+             to pending: each round decides the new text. The studio plays a
+             sound and changes the page title.
+             --literal (only with --script): the request was a ready literal
+             script; the round is born approved (by: "literal") and the flow
+             proceeds to motion without waiting.
+   wait      blocks until the round ends and prints the result. Exits with
+               0  approved (by the user or the deadline): proceed. On the
+                  script, "editado pelo usuário" means script.md changed in
+                  the UI: read it again and don't undo the edit
+               3  change requested: the request is printed
+               4  the countdown stayed paused longer than the whole deadline
+                  (the user opened a change and didn't come back): stop; the
+                  studio resumes the session when the round ends
+             A short pause doesn't interrupt: it keeps waiting. With 0 or 3,
+             marks the result as delivered to Claude.
+   decide, approve-all, pause, resume
+             what the UI does; decide and approve-all are for when the user
+             answers in the chat. Editing the script (edit) is UI-only: it
+             writes script.md and approves.
+
+   Writes motion/approval.json (scenes) or script-approval.json (script):
+
+     { "round": 1, "opened_at": "…", "deadline": "…",
+       "mode": "auto" | "paused",
+       "paused_at": "…" | null, "remaining_ms": 412000 | null,
+       "scenes": { "c01": { "state": "pending" | "approved" | "change_requested",
+                            "comment": "", "at": "…" | null,
+                            "by": "user" | "auto" | "literal" | null } },
+       "completed_at": "…" | null, "delivered_at": "…" | null,
+       "resumed_at": "…" | null }
+
+   On the script, instead of "scenes" comes "items": { "script": { …, "edited": true } }.
+
+   With `mode: "paused"`, `deadline` doesn't count: what's left is in
+   `remaining_ms`, and resume sets `deadline = now + remaining_ms`. An expired
+   deadline is applied by whoever reads first (this tool, the studio or
+   `omnivideo.py status`): nothing has to stay open.
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { keepPrevious } from "./history.mjs";
+import { isNarrated } from "./lib/narration.mjs";
+import { isMainModule, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+export const DEFAULTS = { enabled: true, auto_approve_min: 10, ...(CFG.motion?.approval ?? {}) };
+export const SCRIPT_DEFAULTS = { enabled: true, auto_approve_min: 10, ...(CFG.script?.approval ?? {}) };
+
+const now = () => new Date().toISOString();
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+const sceneIds = dir => (readJson(join(dir, "scenes.json"))?.scenes ?? []).map(s => s.id);
+
+/* what the round decides: the motion script's scenes, one by one, or the whole script */
+const TARGETS = {
+  scenes: {
+    file: dir => join(dir, "motion", "approval.json"),
+    key: "scenes",
+    defaults: DEFAULTS,
+    ids: sceneIds,
+    of: "de cenas",
+    ofThese: "destas cenas",
+    flag: "",
+    missing: "o scenes.json não tem cenas: escreva o roteiro de motion antes",
+  },
+  script: {
+    file: dir => join(dir, "script-approval.json"),
+    key: "items",
+    defaults: SCRIPT_DEFAULTS,
+    ids: dir => (existsSync(join(dir, "script.md")) ? ["script"] : []),
+    of: "do roteiro",
+    ofThese: "deste roteiro",
+    flag: " --script",
+    missing: "o vídeo não tem script.md: escreva o roteiro antes",
+  },
+};
+const items = a => a.scenes ?? a.items ?? {};
+
+/* item state → the PT word printed for the user */
+const STATE_LABEL = { pending: "pendente", approved: "aprovada", change_requested: "alterar" };
+
+function write(dir, a, kind = "scenes") {
+  const file = TARGETS[kind].file(dir);
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(a, null, 2) + "\n");
+  renameSync(tmp, file);
+}
+
+/* finished when nothing is pending */
+function complete(a, when = now()) {
+  if (!a.completed_at && Object.values(items(a)).every(c => c.state !== "pending")) a.completed_at = when;
+  return a;
+}
+
+/* The round as it is now, with an expired deadline already applied: what is
+   pending becomes approved by the deadline. null: the video has no round. */
+export function read(dir, kind = "scenes") {
+  const a = readJson(TARGETS[kind].file(dir));
+  if (!a) return null;
+  /* round written before pausing existed: "manual" stopped forever */
+  if (a.mode === "manual")
+    Object.assign(a, {
+      mode: "paused",
+      paused_at: a.manual_since ?? now(),
+      remaining_ms: TARGETS[kind].defaults.auto_approve_min * 60_000,
+    });
+  if (a.mode === "auto" && !a.completed_at && Date.now() >= Date.parse(a.deadline)) {
+    for (const c of Object.values(items(a))) {
+      if (c.state === "pending") Object.assign(c, { state: "approved", at: a.deadline, by: "auto" });
+    }
+    complete(a, a.deadline);
+    write(dir, a, kind);
+  }
+  return a;
+}
+
+/* summary for the UI and the output: pending, change_requested or approved */
+export function summarize(a) {
+  if (!a) return null;
+  const all = Object.entries(items(a));
+  const changeRequests = all
+    .filter(([, c]) => c.state === "change_requested")
+    .map(([id, c]) => ({ id, comment: c.comment }));
+  return {
+    ...a,
+    status: !a.completed_at ? "pending" : changeRequests.length ? "change_requested" : "approved",
+    pending_count: all.filter(([, c]) => c.state === "pending").length,
+    change_requests: changeRequests,
+    auto_count: all.filter(([, c]) => c.by === "auto").length,
+  };
+}
+
+export function open(dir, { all = false, reopen = [], literal = false } = {}, kind = "scenes") {
+  const { ids, key, defaults, missing, file } = TARGETS[kind];
+  const list = ids(dir);
+  if (!list.length) return { ok: false, error: missing };
+  const previous = readJson(file(dir));
+  /* the script comes back whole: each round decides the new text */
+  const before = all || kind === "script" ? null : previous;
+  const t = now();
+  const decided = Object.fromEntries(
+    list.map(id => {
+      const c = before?.[key]?.[id];
+      const keep = c?.state === "approved" && !reopen.includes(id);
+      return [id, keep ? c : { state: "pending", comment: "", at: null, by: null }];
+    }),
+  );
+  /* approval disabled in the config: the round is born approved */
+  if (!defaults.enabled)
+    for (const c of Object.values(decided))
+      if (c.state === "pending") Object.assign(c, { state: "approved", at: t, by: "auto" });
+  /* literal script: the request already was the final text, so the user approved it by sending it */
+  if (literal && kind === "script")
+    for (const c of Object.values(decided)) Object.assign(c, { state: "approved", comment: "", at: t, by: "literal" });
+  const a = complete(
+    {
+      round: (previous?.round ?? 0) + 1,
+      opened_at: t,
+      deadline: new Date(Date.parse(t) + defaults.auto_approve_min * 60_000).toISOString(),
+      mode: "auto",
+      paused_at: null,
+      remaining_ms: null,
+      [key]: decided,
+      completed_at: null,
+      delivered_at: null,
+      resumed_at: null,
+    },
+    t,
+  );
+  write(dir, a, kind);
+  return { ok: true, approval: a };
+}
+
+function changeRound(dir, fn, kind = "scenes") {
+  const a = read(dir, kind);
+  if (!a)
+    return {
+      ok: false,
+      error: `este vídeo não tem aprovação ${TARGETS[kind].of} aberta (approval.mjs open${TARGETS[kind].flag})`,
+    };
+  if (a.completed_at) return { ok: false, error: `a aprovação ${TARGETS[kind].ofThese} já terminou` };
+  const error = fn(a);
+  if (error) return { ok: false, error };
+  complete(a);
+  write(dir, a, kind);
+  return { ok: true, approval: a };
+}
+
+/* the user opened a change: the countdown pauses and keeps what's left */
+export function pause(dir, kind = "scenes") {
+  return changeRound(
+    dir,
+    a => {
+      if (a.mode === "auto")
+        Object.assign(a, {
+          mode: "paused",
+          paused_at: now(),
+          remaining_ms: Math.max(0, Date.parse(a.deadline) - Date.now()),
+        });
+    },
+    kind,
+  );
+}
+
+/* the change was confirmed (or cancelled): the countdown resumes where it stopped */
+export function resume(dir, kind = "scenes") {
+  return changeRound(
+    dir,
+    a => {
+      if (a.mode !== "paused") return;
+      const deadline = new Date(Date.now() + (a.remaining_ms ?? 0)).toISOString();
+      Object.assign(a, { mode: "auto", deadline, paused_at: null, remaining_ms: null });
+    },
+    kind,
+  );
+}
+
+export function decide(dir, id, decision, comment = "", kind = id === "script" ? "script" : "scenes") {
+  if (!["approve", "change"].includes(decision)) return { ok: false, error: "decisão: approve ou change" };
+  const text = String(comment ?? "").trim();
+  if (decision === "change" && !text)
+    return {
+      ok: false,
+      error: `diga o que mudar ${kind === "script" ? "no roteiro" : "na cena"}: é o que o Claude vai ajustar`,
+    };
+  return changeRound(
+    dir,
+    a => {
+      const c = items(a)[id];
+      if (!c) return `${kind === "script" ? "o roteiro" : `a cena ${id}`} não está nesta aprovação`;
+      Object.assign(c, {
+        state: decision === "approve" ? "approved" : "change_requested",
+        comment: text,
+        at: now(),
+        by: "user",
+      });
+    },
+    kind,
+  );
+}
+
+export function approveAll(dir, kind = "scenes") {
+  return changeRound(
+    dir,
+    a => {
+      for (const c of Object.values(items(a)))
+        if (c.state === "pending") Object.assign(c, { state: "approved", at: now(), by: "user" });
+    },
+    kind,
+  );
+}
+
+/* the user edited the script in the UI: their text counts as approved, and
+   the previous version goes to history/script/ */
+export function edit(dir, text) {
+  const updated = String(text ?? "").replace(/\r\n/g, "\n");
+  if (!updated.trim()) return { ok: false, error: "o roteiro ficou vazio" };
+  const a = read(dir, "script");
+  if (!a) return { ok: false, error: "este vídeo não tem aprovação do roteiro aberta" };
+  if (a.completed_at) return { ok: false, error: "a aprovação deste roteiro já terminou" };
+  const previous = keepPrevious(dir, "script", null, ["script.md"]);
+  writeFileSync(join(dir, "script.md"), updated.endsWith("\n") ? updated : `${updated}\n`);
+  previous.close();
+  return changeRound(
+    dir,
+    r => {
+      Object.assign(items(r).script, { state: "approved", comment: "", at: now(), by: "user", edited: true });
+    },
+    "script",
+  );
+}
+
+/* the result reached Claude: through `wait`'s output or the resumed session */
+export function mark(dir, field, kind = "scenes") {
+  const a = readJson(TARGETS[kind].file(dir));
+  if (!a || a[field]) return;
+  a[field] = now();
+  write(dir, a, kind);
+}
+
+/* --- command line ---------------------------------------------------------- */
+const clock = iso => new Date(iso).toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
+const minutes = ms => {
+  const s = Math.round(ms / 1000);
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+};
+
+function report(e, kind = "scenes") {
+  const rows = Object.entries(items(e)).map(
+    ([id, c]) =>
+      `  ${c.state === "approved" ? "✓" : c.state === "change_requested" ? "✎" : "·"} ${id}  ${STATE_LABEL[c.state] ?? c.state}${c.by === "auto" ? " (pelo prazo)" : ""}` +
+      `${c.edited ? " (editado pelo usuário na tela: leia o script.md de novo e não desfaça a edição)" : ""}${c.comment ? `: ${c.comment}` : ""}`,
+  );
+  const isScript = kind === "script";
+  const left = isScript ? "o roteiro está pendente" : `${e.pending_count} cena(s) pendente(s)`;
+  const head =
+    e.status === "pending"
+      ? e.mode === "paused"
+        ? `rodada ${e.round}: contagem pausada desde ${clock(e.paused_at)} (o usuário está editando); faltam ${minutes(e.remaining_ms ?? 0)} quando ela voltar; ${left}`
+        : `rodada ${e.round}: ${left}; ${isScript ? "aprova sozinho" : "aprovam sozinhas"} às ${clock(e.deadline)}`
+      : e.status === "change_requested"
+        ? `rodada ${e.round}: ${isScript ? "o roteiro pede alteração" : `${e.change_requests.length} cena(s) pedem alteração`}`
+        : `rodada ${e.round}: ${isScript ? `roteiro aprovado${e.auto_count ? " (pelo prazo)" : ""}` : `todas aprovadas${e.auto_count ? ` (${e.auto_count} pelo prazo)` : ""}`}`;
+  console.log([head, ...rows].join("\n"));
+}
+
+async function wait(dir, kind = "scenes") {
+  const { defaults, of, flag } = TARGETS[kind];
+  for (;;) {
+    const a = read(dir, kind);
+    if (!a) {
+      console.error(`erro: este vídeo não tem aprovação ${of} aberta (approval.mjs open${flag})`);
+      process.exit(2);
+    }
+    const e = summarize(a);
+    if (e.status !== "pending") {
+      mark(dir, "delivered_at", kind);
+      report(e, kind);
+      process.exit(e.status === "approved" ? 0 : 3);
+    }
+    /* a short pause is the user typing: keep waiting. A pause longer than the
+       whole deadline is an abandoned edit: release the session */
+    if (e.mode === "paused" && Date.now() - Date.parse(e.paused_at) > defaults.auto_approve_min * 60_000) {
+      report(e, kind);
+      console.log(
+        "pare aqui: a contagem está pausada há mais que o prazo. O studio retoma a sessão quando a rodada terminar; no chat, o usuário avisa.",
+      );
+      process.exit(4);
+    }
+    await new Promise(r => setTimeout(r, 2000));
+  }
+}
+
+if (isMainModule(import.meta.url)) {
+  const args = process.argv.slice(2);
+  const [cmd, target, ...rest] = args.filter(a => a !== "--script");
+  const fail = msg => {
+    console.error(`erro: ${msg}`);
+    process.exit(1);
+  };
+  if (!cmd || !target)
+    fail("uso: approval.mjs open|wait|show|decide|approve-all|pause|resume videos/<slug> [--script]");
+  const kind = args.includes("--script") || (cmd === "decide" && rest[0] === "script") ? "script" : "scenes";
+  const dir = resolve(target);
+  if (kind === "scenes" && !existsSync(join(dir, "scenes.json"))) fail(`${target} não tem scenes.json`);
+  if (kind === "script" && !isNarrated(dir))
+    fail(`${target} é sem narração e voz (content.json): não há roteiro falado para aprovar`);
+  if (kind === "script" && !existsSync(join(dir, "script.md"))) fail(`${target} não tem script.md`);
+  const done = r => {
+    if (!r.ok) fail(r.error);
+    report(summarize(r.approval), kind);
+  };
+  switch (cmd) {
+    case "open": {
+      const i = rest.indexOf("--reopen");
+      done(
+        open(
+          dir,
+          {
+            all: rest.includes("--all"),
+            literal: rest.includes("--literal"),
+            reopen:
+              i < 0
+                ? []
+                : String(rest[i + 1] ?? "")
+                    .split(",")
+                    .filter(Boolean),
+          },
+          kind,
+        ),
+      );
+      /* the user approves the scenes looking at the wireframe (av-motion, tools/wireframe.mjs) */
+      if (kind === "scenes") {
+        const noWireframe = sceneIds(dir).filter(id => !existsSync(join(dir, "motion", "wireframes", `${id}.png`)));
+        if (noWireframe.length)
+          console.warn(`aviso: sem wireframe para ${noWireframe.join(", ")} (node tools/wireframe.mjs ${target})`);
+      }
+      break;
+    }
+    case "wait":
+      await wait(dir, kind);
+      break;
+    case "show": {
+      const a = read(dir, kind);
+      if (!a) fail("sem aprovação aberta");
+      report(summarize(a), kind);
+      break;
+    }
+    case "decide":
+      done(decide(dir, rest[0], rest[1], rest.slice(2).join(" "), kind));
+      break;
+    case "approve-all":
+      done(approveAll(dir, kind));
+      break;
+    case "pause":
+      done(pause(dir, kind));
+      break;
+    case "resume":
+      done(resume(dir, kind));
+      break;
+    default:
+      fail(`comando desconhecido: ${cmd}`);
+  }
+}