Files
MateuusandClaude Opus 5.5 84f30bbc2d CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 16:35:09 -03:00

175 lines
7.6 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Confere um roteiro (.md) e os JSON da história sem LLM: duração, narração, trechos e campos.
Mesmas regras do leitor de roteiro do painel (panel/src/lib/script-doc.ts):
- duração alvo = linha de metadados "Duração: 60 s" (antes do primeiro "##");
- trechos = primeira tabela cuja 1ª coluna é o tempo ("t (s)" / "Tempo");
- narração lida a 2,5 palavras por segundo (doc/roteiro/comum.md).
Confere também, na pasta da história: meta.json (title ≤ 60, logline) e *.choices.json
(opções ≤ 60 caracteres, distintas).
Uso:
python .claude/skills/cenaforge/scripts/check_script.py stories/<história>/ep01.md
python .claude/skills/cenaforge/scripts/check_script.py stories/<história> (todos os ep*.md)
Saída: poucas linhas; código 0 = ok, 2 = há avisos, 1 = erro de leitura.
"""
from __future__ import annotations
import argparse
import json
import re
from pathlib import Path
from _common import rel, utf8_stdout
WORDS_PER_SECOND = 2.5
TOLERANCE = 0.15
MAX_LABEL = 60
WORD = re.compile(r"[^\W_][\w'’-]*", re.UNICODE)
def count_words(text: str) -> int:
return len(WORD.findall(re.sub(r"[*_`\"“”]", " ", text)))
def split_row(line: str) -> list[str]:
return [c.strip() for c in line.strip().strip("|").split("|")]
def is_separator(line: str) -> bool:
return bool(re.match(r"^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$", line))
def parse(markdown: str):
lines = markdown.replace("\r\n", "\n").split("\n")
meta, body, seen_h2 = [], [], False
for line in lines:
if line.startswith("## "):
seen_h2 = True
if not seen_h2 and line.strip() and not line.startswith("# "):
meta.append(line.strip())
if seen_h2:
body.append(line)
target = None
for part in (p for m in meta for p in re.split(r"\s+·\s+", m)):
m = re.match(r"^([^:]{2,40}):\s*(.+)$", part)
if m and re.search(r"dura[cç][aã]o", m.group(1), re.I):
num = re.search(r"\d+", m.group(2))
target = int(num.group()) if num else None
shots = []
for i, line in enumerate(body):
if line.strip().startswith("|") and i + 1 < len(body) and is_separator(body[i + 1]):
header = split_row(line)
if not re.match(r"^t\b|tempo", header[0] if header else "", re.I):
continue
col = lambda pattern: next((k for k, h in enumerate(header) if re.search(pattern, h, re.I)), -1)
narr, visual = col(r"narra|di[aá]logo|fala"), col(r"imagem|b-?roll|visual")
j = i + 2
while j < len(body) and body[j].strip().startswith("|"):
row = split_row(body[j])
nums = [float(n.replace(",", ".")) for n in re.findall(r"\d+(?:[.,]\d+)?", row[0] if row else "")]
shots.append({
"time": row[0] if row else "",
"start": nums[0] if nums else None,
"end": nums[1] if len(nums) > 1 else None,
"narration": row[narr] if 0 <= narr < len(row) else "",
"visual": row[visual] if 0 <= visual < len(row) else "",
"has_visual_col": visual >= 0,
})
j += 1
break
return target, shots
def check_episode(path: Path) -> list[str]:
target, shots = parse(path.read_text(encoding="utf-8"))
words = sum(count_words(s["narration"]) for s in shots)
spoken = words / WORDS_PER_SECOND
warnings: list[str] = []
head = f"{rel(path)}: {len(shots)} trechos · narração {words} palavras ≈ {spoken:.0f} s"
head += f" · alvo {target} s" if target else " · SEM duração alvo"
print(head)
if not target:
warnings.append("falta a linha 'Duração: <n> s' antes do primeiro '##'")
elif abs(spoken - target) > TOLERANCE * target:
warnings.append(f"narração ({spoken:.0f} s) foge mais de {TOLERANCE:.0%} do alvo ({target} s)")
if not shots:
warnings.append("sem tabela de trechos (1ª coluna 't (s)')")
previous_end = None
for n, shot in enumerate(shots, 1):
if shot["start"] is not None and previous_end is not None and abs(shot["start"] - previous_end) > 0.05:
warnings.append(f"trecho {n} ({shot['time']}): começa em {shot['start']:g}, o anterior terminou em {previous_end:g}")
if shot["start"] is not None and shot["end"] is not None:
length = shot["end"] - shot["start"]
need = count_words(shot["narration"]) / WORDS_PER_SECOND
if length <= 0:
warnings.append(f"trecho {n} ({shot['time']}): tempo inválido")
elif need > length + 0.5:
warnings.append(f"trecho {n} ({shot['time']}): narração pede {need:.1f} s em {length:g} s")
if shot["has_visual_col"] and not shot["visual"]:
warnings.append(f"trecho {n} ({shot['time']}): coluna Imagem vazia")
previous_end = shot["end"] if shot["end"] is not None else previous_end
if shots and target and previous_end is not None and abs(previous_end - target) > 1:
warnings.append(f"último trecho termina em {previous_end:g} s; alvo {target} s")
return warnings
def check_story_json(story_dir: Path) -> list[str]:
warnings: list[str] = []
meta = story_dir / "meta.json"
if meta.is_file():
try:
data = json.loads(meta.read_text(encoding="utf-8"))
title = str(data.get("title") or "")
if not title or len(title) > MAX_LABEL:
warnings.append(f"meta.json: title vazio ou com mais de {MAX_LABEL} caracteres ({len(title)})")
if not str(data.get("logline") or "").strip():
warnings.append("meta.json: logline vazia")
except json.JSONDecodeError as error:
warnings.append(f"meta.json inválido: {error}")
for choices in sorted(story_dir.glob("*.choices.json")):
try:
data = json.loads(choices.read_text(encoding="utf-8"))
except json.JSONDecodeError as error:
warnings.append(f"{choices.name} inválido: {error}")
continue
labels = [str(v).strip() for v in data.values()] if isinstance(data, dict) else []
if not labels:
warnings.append(f"{choices.name}: esperado objeto {{\"A\": \"...\", \"B\": \"...\"}}")
for letter, label in (data.items() if isinstance(data, dict) else []):
if not str(label).strip() or len(str(label)) > MAX_LABEL:
warnings.append(f"{choices.name}: opção {letter} vazia ou com mais de {MAX_LABEL} caracteres")
if len({l.lower() for l in labels}) < len(labels):
warnings.append(f"{choices.name}: opções repetidas")
return warnings
def main() -> int:
utf8_stdout()
ap = argparse.ArgumentParser(description="Confere roteiro e JSON da história, sem LLM.")
ap.add_argument("target", help="episódio .md ou pasta da história")
args = ap.parse_args()
target = Path(args.target).resolve()
if target.is_dir():
story_dir, episodes = target, sorted(target.glob("ep*.md"))
elif target.is_file():
story_dir, episodes = target.parent, [target]
else:
print("não encontrado:", args.target)
return 1
warnings: list[str] = []
for episode in episodes:
warnings += check_episode(episode)
warnings += check_story_json(story_dir)
for w in warnings[:20]:
print(" AVISO " + w)
if len(warnings) > 20:
print(f" ... e mais {len(warnings) - 20} avisos")
print("ok" if not warnings else f"{len(warnings)} aviso(s)")
return 2 if warnings else 0
if __name__ == "__main__":
raise SystemExit(main())