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>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+640
View File
@@ -0,0 +1,640 @@
"""IA do Clipador pelas CLIs já logadas no PC (Codex/GPT por padrão, ou Claude) — sem chave de API.
Quatro usos, todos com saída JSON validada por schema:
1. **juiz** de candidato (chat/áudio apontaram): manter/descartar, nota, início/fim, título e legenda. Vê a
transcrição com bastante tempo para trás (o comentário vem DEPOIS da ação), o chat, os emotes, o perfil do
jogo e FRAMES da tela.
2. **varredura**: a cada poucos minutos de gravação a IA olha a janela inteira (fala + tela + chat) e propõe
momentos mesmo sem pico de chat — essencial em live pequena (3–5 pessoas) ou chat que reage pouco.
3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades.
4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima.
Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`) ou `claude`
(`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch).
"""
from __future__ import annotations
import json
import logging
import os
import re
import shutil
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from pathlib import Path
from . import layout
from .scoring import ChatMessage, Word, fit_window
log = logging.getLogger("cenaforge_clipper.judge")
PROVIDERS = ("codex", "claude", "off")
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku"}
CLAUDE_MODELS = [
{"id": "haiku", "label": "Haiku (mais barato)"},
{"id": "sonnet", "label": "Sonnet (equilíbrio)"},
{"id": "opus", "label": "Opus (mais capaz, mais caro)"},
]
CONTEXT_AFTER_S = 15.0
# Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min.
DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"])
DEFAULT_MAX_S = float(layout.DEFAULTS["duration"]["maxS"])
DEFAULT_BACKTRACK_S = float(layout.DEFAULTS["duration"]["backtrackS"])
TIMEOUT_S, RESEARCH_TIMEOUT_S = 240, 420
NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
# Economia de tokens (medido em 17/11/2026, codex-cli 0.169.0): cada chamada do juiz é um processo novo e
# pagava ~77 mil caracteres fixos (~19 mil tokens) antes do prompt — instruções de agente de código (18 mil),
# ferramentas (46 mil: exec, plugins, computer-use) e listas de skills/apps. Uma live de 3,7 h = 150 chamadas.
# Sem busca na web o juiz não usa ferramenta nenhuma (as imagens vão por `-i`), então: o texto do juiz
# substitui as instruções de base e os recursos com ferramentas saem. Resultado: ~35 mil caracteres fixos.
# Com `--search` (pesquisa de jogo) só saem os extras; a web do Codex depende das ferramentas de execução.
CODEX_TOOL_FEATURES = ("plugins", "apps", "shell_tool", "unified_exec", "code_mode_host", "sleep_tool",
"skill_search", "tool_suggest", "in_app_browser", "browser_use")
CODEX_EXTRA_FEATURES = ("computer_use", "image_generation", "goals", "hooks")
CODEX_UNUSED_PLUGINS = ("computer-use@openai-bundled", "unified-computer-use@openai-bundled")
def codex_lean_overrides(search: bool, config_file: Path | None = None) -> list[str]:
"""Overrides `-c` só para esta chamada (a config global do Codex não muda)."""
features = CODEX_EXTRA_FEATURES + (() if search else CODEX_TOOL_FEATURES)
overrides = [f"features.{name}=false" for name in features]
try:
config = (config_file or Path.home() / ".codex" / "config.toml").read_text(encoding="utf-8")
except OSError:
config = ""
# `-c mcp_servers={}` não desliga (o Codex mescla tabelas): é preciso `enabled=false` por servidor.
for name in dict.fromkeys(re.findall(r'^\s*\[mcp_servers\.("?)([A-Za-z0-9_-]+)\1\]\s*$', config, re.M)):
overrides.append(f"mcp_servers.{name[1]}.enabled=false")
for plugin in CODEX_UNUSED_PLUGINS:
if f'[plugins."{plugin}"]' in config:
overrides.append(f'plugins."{plugin}".enabled=false')
return [arg for item in overrides for arg in ("-c", item)]
# ---------------------------------------------------------------- guia editorial (pesquisa de 16–17/11/2026)
CLIP_GUIDE = """O que faz um bom corte de live (pesquisa de mercado, 2026):
- Abre no momento forte: o espectador decide em 1–2 s. Nada de "como eu tava falando".
- Se explica sozinho: quem nunca viu a live entende em poucos segundos (contexto mínimo no começo).
- Rende corte: reação forte (susto, risada, raiva), jogada absurda/virada, falha engraçada, treta, história que
se desenrola, fala marcante, e INFORMAÇÃO NOVA DO JOGO (mecânica, segredo, novidade, comparação) — em
lançamentos (ex.: GTA 6) informação vale tanto quanto reação.
- Não rende: espera, menu/loading, leitura de doação/propaganda, conversa sem gancho, piada interna da live.
- TEMPO: o streamer costuma comentar DEPOIS da ação. Volte até o início da AÇÃO que motivou o comentário (pode
ser de 20 s a 2 min antes da fala, até o limite de volta informado) — o corte precisa mostrar a ação e a reação.
- Corte justo: termina logo depois do pagamento (reação/resolução)."""
# Gírias/memes do chat (BR/Twitch) que mudam o sentido do momento. O analista interpreta com o contexto.
CHAT_GLOSSARY = """Gírias comuns do chat (interprete pelo contexto):
- "server chinês", "ping", "lag", "travou/travando", "exit lag", "bugou", "rubberband", "teleportou" → o jogo ou a
live está travando/com atraso (personagem pulando de lugar, morrendo do nada) — a graça é o lag.
- "kkkk", "KEKW", "LUL", "OMEGALUL", "ICANT", "PepeLaugh" → risada; "?????" → confusão/não entenderam;
"F" → morte/perda/luto; "W"/"L" → vitória/derrota; "Pog/POGGERS" → impressionados; "monkaS/monkaW" → tensão;
"clipa/clip it" → pedido de corte; "hack/hackudo" → suspeita de trapaça; "gg" → fim de partida.
- Emotes próprios do canal (prefixo do streamer, ex.: skpPog) carregam a mesma reação do emote original."""
SITUATIONS = ("lag_ou_bug", "jogada", "falha_engracada", "morte", "susto", "treta", "conversa_engracada",
"historia", "informacao_do_jogo", "reacao", "outro")
ANALYSIS_SCHEMA = {
"type": "object",
"properties": {
"situation": {"type": "string", "enum": list(SITUATIONS)},
"what_happened": {"type": "string"},
"screen": {"type": "string"},
"speech": {"type": "string"},
"chat_meaning": {"type": "string"},
"confidence": {"type": "number"},
"action_start_s": {"type": "number"},
"reaction_end_s": {"type": "number"},
"hook": {"type": "string"},
},
"required": ["situation", "what_happened", "screen", "speech", "chat_meaning", "confidence",
"action_start_s", "reaction_end_s", "hook"],
"additionalProperties": False,
}
ANALYST_SYSTEM = """Você é o ANALISTA de uma equipe de cortes de live. Não escreve título: descreve com fidelidade
O QUE ACONTECEU no trecho, para o editor decidir. Recebe contexto do jogo, transcrição com tempos, FRAMES da tela
com o instante de cada um e o chat.
Cruze as três fontes antes de concluir: a fala sozinha engana (ex.: "tô jogando três jogos… morri, morri" junto
de chat "server chinês?/kkkk" e a tela pulando = o jogo está travando e ele morre por causa do lag, não está
jogando três jogos). O chat reage alguns segundos depois do acontecimento.
""" + CHAT_GLOSSARY + """
Campos:
- situation: o tipo do momento (um da lista).
- what_happened: 2–3 frases factuais do que aconteceu, na ordem, sem exagero.
- screen: o que os frames mostram (cite o nº do frame) — ou "frames não ajudam".
- speech: o que a fala revela (cite o instante).
- chat_meaning: o que o chat está dizendo/rindo e por quê.
- confidence: 0–1, quanto você tem certeza da interpretação (baixe se as fontes não batem).
- action_start_s: instante (s da gravação) em que começa a AÇÃO que gerou a reação (pode ser antes da fala).
- reaction_end_s: instante em que a reação/pagamento termina.
- hook: o que prenderia alguém nos 2 primeiros segundos do corte.
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
VERDICT_SCHEMA = {
"type": "object",
"properties": {
"keep": {"type": "boolean"},
"score": {"type": "number"},
"start_s": {"type": "number"},
"end_s": {"type": "number"},
"title": {"type": "string"},
"caption": {"type": "string"},
"hashtags": {"type": "array", "items": {"type": "string"}},
"reason": {"type": "string"},
},
"required": ["keep", "score", "start_s", "end_s", "title", "caption", "hashtags", "reason"],
"additionalProperties": False,
}
# A varredura só aponta momentos (o juiz escreve título/legenda/hashtags depois): sem `keep` e sem `hashtags`.
_MOMENT = {
"type": "object",
"properties": {k: v for k, v in VERDICT_SCHEMA["properties"].items() if k not in ("keep", "hashtags")},
"required": ["score", "start_s", "end_s", "title", "caption", "reason"],
"additionalProperties": False,
}
SCAN_SCHEMA = {
"type": "object",
"properties": {
"screen_game": {"type": "string"},
"has_webcam": {"type": "boolean"},
"summary": {"type": "string"},
"moments": {"type": "array", "items": _MOMENT},
},
"required": ["screen_game", "has_webcam", "summary", "moments"],
"additionalProperties": False,
}
PROFILE_SCHEMA = {
"type": "object",
"properties": {
"name": {"type": "string"},
"summary": {"type": "string"},
"genre": {"type": "string"},
"mechanics": {"type": "array", "items": {"type": "string"}},
"clip_worthy": {"type": "array", "items": {"type": "string"}},
"avoid": {"type": "array", "items": {"type": "string"}},
"jargon": {"type": "array", "items": {"type": "string"}},
"news": {"type": "array", "items": {"type": "string"}},
"hashtags": {"type": "array", "items": {"type": "string"}},
"sources": {"type": "array", "items": {"type": "string"}},
},
"required": ["name", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources"],
"additionalProperties": False,
}
CAM_SCHEMA = {
"type": "object",
"properties": {
"has_webcam": {"type": "boolean"},
"x": {"type": "number"}, "y": {"type": "number"}, "w": {"type": "number"}, "h": {"type": "number"},
"game_on_screen": {"type": "string"},
},
"required": ["has_webcam", "x", "y", "w", "h", "game_on_screen"],
"additionalProperties": False,
}
JUDGE_SYSTEM = """Você é o EDITOR de cortes de live para Shorts, TikTok, Reels e YouTube, em português do Brasil.
Recebe um trecho candidato de uma live (contexto do jogo, transcrição com tempos, chat, emotes) e, quando houver,
a ANÁLISE do analista da equipe, que já cruzou tela, fala e chat. Confie na análise para entender O QUE
aconteceu; o seu trabalho é decidir se rende corte e escrever título e legenda FIÉIS a isso.
""" + CLIP_GUIDE + """
""" + CHAT_GLOSSARY + """
Título e legenda: descrevem a situação real (ex.: se a análise diz lag, o título é sobre o lag/travamento, não
sobre a frase solta da transcrição). Com confidence da análise < 0,5, seja descritivo e não invente detalhes.
Use action_start_s/reaction_end_s da análise como base para start_s/end_s."""
JUDGE_SYSTEM += """
Regras da resposta:
- keep=false para o que não rende; score de 0 a 10 (7+ = corte forte; abaixo de 5 = descartar).
- start_s e end_s em segundos da gravação, DENTRO da janela recebida e respeitando a duração mínima/máxima
informada; comece antes da ação (contexto) e termine logo depois da reação. Não corte no meio de uma frase.
- title: até 70 caracteres, chamativo mas verdadeiro, sem inventar o que não está na fala/tela.
- caption: 1–2 frases, SEM hashtags e sem link (o sistema acrescenta as hashtags do canal e do jogo e o crédito).
- hashtags: 2 a 4 tags DO MOMENTO, sem "#": a missão/atividade, o evento, o modo, o lugar, o item ou o personagem
que aparece NESTE trecho (ex.: nome da missão ou do assalto, "perseguição", "sorteio", "Lamborghini", "lag").
Prefira os termos do perfil do jogo (mecânicas, gírias) e o que o streamer e o chat falam. Nada genérico
("gameplay", "live", "viral"), nada que não aconteça aqui, e não repita o canal nem o nome do jogo.
- reason: uma frase dizendo por que manteve ou descartou (cite o que viu na tela, se ajudou).
- Não use ferramentas nem leia nada além do que foi entregue. Responda só com o JSON pedido."""
SCAN_SYSTEM = """Você é editor de cortes de live e está ASSISTINDO uma live por janelas de alguns minutos.
Recebe o contexto do jogo, a transcrição com tempos (segundos da gravação), frames da tela com o instante de
cada um, o chat (pode ser quase vazio: live pequena) e os cortes já feitos nessa região.
""" + CLIP_GUIDE + """
Tarefa: aponte de 0 a 2 momentos desta janela que dariam um bom corte SOZINHOS. Se nada rende, devolva
moments=[] (é o normal na maior parte do tempo — não force). Não repita um corte já feito.
- start_s/end_s dentro da janela recebida (pode começar até o limite de "volta" informado para pegar a ação),
com a duração mínima/máxima informada.
- screen_game: o jogo que aparece na tela (ou "desconhecido"); has_webcam: há câmera do streamer no quadro?
- summary: 1 frase do que está acontecendo na janela (vira memória para as próximas janelas).
- title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
PROFILE_SYSTEM = """Você pesquisa jogos para um editor de cortes de live em português do Brasil. Use a busca na
web para confirmar o que é o jogo (nome da categoria da Twitch pode ser abreviado ou ambíguo). Seja factual e
cite as fontes (URLs). Responda só com o JSON pedido, textos em português do Brasil.
- summary: 2–3 frases do que é o jogo e como se joga.
- mechanics: até 8 mecânicas/sistemas que aparecem em gameplay.
- clip_worthy: até 10 situações que rendem corte NESTE jogo (específicas, não genéricas).
- avoid: até 6 situações que parecem momento mas não rendem (menus, farm, fila...).
- jargon: até 12 termos/gírias que streamer e chat usam (para entender a transcrição).
- news: até 6 novidades recentes com mês/ano (lançamento, atualização, polêmica) que tornam informação valiosa.
- hashtags: 3 a 6 hashtags que o público usa para ESTE jogo no TikTok, Shorts e Reels (Brasil): o nome do jogo sem
espaço, abreviação conhecida, o modo/gênero quando for buscado (ex.: GTARP). A primeira é a principal do jogo.
Escreva com "#", sem inventar tag que ninguém usa.
- sources: até 5 URLs usadas.
Se vierem "pedidos do usuário", eles valem mais que a pesquisa: inclua o que ele pediu para acrescentar e respeite
o que ele mandou tirar ou corrigir (ele conhece o canal e o jogo)."""
REFINE_SYSTEM = """Você mantém o perfil de um jogo usado por um editor de cortes de live em português do Brasil.
Recebe o perfil ATUAL (JSON) e um PEDIDO do usuário (acrescentar, corrigir, tirar ou detalhar algo). Devolva o
perfil COMPLETO atualizado, no mesmo formato:
- mantenha tudo o que o pedido não mexe, com o mesmo texto;
- aplique o pedido no campo certo (situação que rende corte → clip_worthy; o que não rende → avoid; gíria → jargon;
mecânica → mechanics; novidade → news com mês/ano; hashtag do jogo → hashtags, com "#", a principal primeiro),
escrito no estilo dos itens que já estão lá;
- os limites de tamanho das listas podem crescer até 15 itens quando o usuário pedir para acrescentar;
- se precisar confirmar um fato, pode usar a busca na web e acrescentar a URL em sources;
- o usuário conhece o canal e o jogo: o que ele afirma vale, mesmo que você não ache na web;
- se vier uma SEÇÃO em foco, o pedido é sobre ela: mexa nela (outras só se o pedido disser);
- pode transformar um pedido genérico em itens concretos e úteis para o editor (ex.: "reação do streamer conta"
vira "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga");
- reply: 1–2 frases para o usuário dizendo o que você mudou (ou, se o pedido for uma pergunta, a resposta).
Textos em português do Brasil. Responda só com o JSON pedido."""
REFINE_SCHEMA = {
"type": "object",
"properties": {**PROFILE_SCHEMA["properties"], "reply": {"type": "string"}},
"required": [*PROFILE_SCHEMA["required"], "reply"],
"additionalProperties": False,
}
PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas",
"hashtags": "Hashtags",
"news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes"}
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e,
se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro:
x, y = canto superior esquerdo; w, h = largura e altura. Sem webcam: has_webcam=false e x=y=w=h=0.
game_on_screen: o jogo que aparece (ou "desconhecido"). Responda só com o JSON pedido."""
@dataclass(frozen=True)
class Verdict:
keep: bool
score: float
start_s: float
end_s: float
title: str
caption: str
reason: str
model: str
# Tags DO MOMENTO (sem "#"), escolhidas pela IA; as do canal e do jogo o sistema põe (app/hashtags.py).
hashtags: tuple[str, ...] = ()
class JudgeError(RuntimeError):
pass
# ---------------------------------------------------------------- prompts
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
confirmed: bool = False) -> str:
lines = [f"Título da live: {live_title or '(desconhecido)'}"]
if confirmed:
# O usuário confirmou no painel: não questionar (jogo novo/pouco conhecido lembra outros na tela).
lines.append(f"Jogo CONFIRMADO pelo usuário: {game}. A tela pode lembrar outro jogo parecido (ex.: GTA, "
f"Warzone) — não questione o jogo; use o perfil abaixo para entender o que acontece.")
else:
lines.append(f"Jogo pela categoria da plataforma: {game or '(desconhecida)'}")
if screen_game and screen_game.lower() not in (game or "").lower():
lines.append(f"Jogo que a IA viu na tela recentemente: {screen_game} (confira nos frames; a categoria pode estar errada)")
if profile:
lines.append(f"Perfil do jogo: {profile.get('summary', '')}")
for key, label in (("clip_worthy", "Rende corte neste jogo"), ("avoid", "Não rende"),
("mechanics", "Mecânicas/atividades (termos para as hashtags do momento)"),
("jargon", "Gírias/termos"), ("news", "Novidades")):
if profile.get(key):
lines.append(f"{label}: " + "; ".join(profile[key][:10]))
if history:
lines.append(f"O que aconteceu antes na live: {history}")
return "\n".join(lines)
def _transcript(words: list[Word], lo: float, hi: float) -> str:
lines, current, current_t = [], [], None
for word in sorted((w for w in words if lo <= w.start <= hi), key=lambda w: w.start):
if current_t is None or word.start - current_t > 4 or len(current) >= 14:
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
current, current_t = [], word.start
current.append(word.word)
if current:
lines.append(f"[{current_t:.0f}s] {' '.join(current)}")
return "\n".join(lines) or "(sem fala transcrita)"
def _chat_block(chat: list[ChatMessage], lo: float, hi: float, focus: float | None, bucket_s: int = 5) -> str:
buckets: dict[int, int] = {}
emotes: dict[str, int] = {}
sample: list[str] = []
for message in chat:
if lo <= message.t <= hi:
b = int(message.t // bucket_s * bucket_s)
buckets[b] = buckets.get(b, 0) + 1
for e in set(message.emotes):
emotes[e] = emotes.get(e, 0) + 1
near = focus is None or focus - 10 <= message.t <= focus + 8
if near and len(sample) < 60:
sample.append(f"[{message.t:.0f}s] {message.text[:80]}")
rate = ", ".join(f"{t}s:{n}" for t, n in sorted(buckets.items())) or "sem chat"
top = ", ".join(f"{e}×{n}" for e, n in sorted(emotes.items(), key=lambda kv: -kv[1])[:12]) or "nenhum"
return (f"Mensagens do chat por {bucket_s} s: {rate}\nEmotes mais usados: {top}\n"
f"Amostra do chat:\n" + ("\n".join(sample) or "(sem chat)"))
def _frames_block(frames: list[tuple[float, Path]]) -> str:
if not frames:
return "Frames: (nenhum)"
return "Frames anexados, em ordem: " + ", ".join(f"#{i + 1} = {t:.0f}s" for i, (t, _) in enumerate(frames))
def build_prompt(streamer: str, platform: str, start_s: float, end_s: float, peak_s: float,
words: list[Word], chat: list[ChatMessage], heuristic: dict, live_title: str = "", *,
context: str = "", frames: list[tuple[float, Path]] | None = None,
backtrack_s: float = DEFAULT_BACKTRACK_S, min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S,
face: str = "") -> str:
"""Prompt do juiz. Janela = candidato com `backtrack_s` para trás (a ação vem antes do comentário).
`face`: resumo do rosto do streamer na janela (face.FaceService.summary); vazio = sem câmera/rastreio."""
lo, hi = max(0.0, start_s - backtrack_s), end_s + CONTEXT_AFTER_S
return (
f"Canal: {streamer} ({platform})\n"
+ (context or f"Título da live: {live_title or '(desconhecido)'}") + "\n\n"
f"Janela disponível: {lo:.0f}s a {hi:.0f}s. Candidato da heurística: {start_s:.0f}s a {end_s:.0f}s; "
f"pico de reação em {peak_s:.0f}s. Duração do corte: {min_s:.0f} a {max_s:.0f} s.\n"
f"Sinais da heurística: {json.dumps(heuristic, ensure_ascii=False)}\n"
+ (f"Rosto do streamer (expressão medida na webcam, relativa ao normal dele): {face}\n" if face else "")
+ f"{_frames_block(frames or [])}\n\n"
f"Transcrição:\n{_transcript(words, lo, hi)}\n\n"
f"{_chat_block(chat, lo, hi, peak_s)}"
)
def build_scan_prompt(streamer: str, platform: str, lo: float, hi: float, back_lo: float, words: list[Word],
chat: list[ChatMessage], context: str, frames: list[tuple[float, Path]],
existing: list[tuple[float, float, str]], min_s: float, max_s: float) -> str:
done = "; ".join(f"{a:.0f}–{b:.0f}s ({t[:40]})" for a, b, t in existing) or "nenhum"
return (
f"Canal: {streamer} ({platform})\n{context}\n\n"
f"Janela nova: {lo:.0f}s a {hi:.0f}s (pode voltar até {back_lo:.0f}s para pegar o início de uma ação).\n"
f"Duração do corte: {min_s:.0f} a {max_s:.0f} s. Cortes já feitos aqui: {done}\n"
f"{_frames_block(frames)}\n\n"
f"Transcrição:\n{_transcript(words, back_lo, hi)}\n\n"
f"{_chat_block(chat, back_lo, hi, None, bucket_s=10)}"
)
def _clean(data: dict, start_s: float, end_s: float, model: str, lo: float | None = None, hi: float | None = None,
min_s: float = DEFAULT_MIN_S, max_s: float = DEFAULT_MAX_S) -> Verdict:
# `hashtags` é opcional na leitura: resposta sem ele (modelo antigo/cache) segue com as tags do canal e do jogo.
missing = [k for k in VERDICT_SCHEMA["required"] if k not in data and k != "hashtags"]
if missing:
raise JudgeError(f"resposta sem os campos {missing}")
lo = max(0.0, start_s - DEFAULT_BACKTRACK_S) if lo is None else lo
hi = end_s + CONTEXT_AFTER_S if hi is None else hi
# Mínimo de verdade (pedido do dono, 17/11/2026): se o fim bate em `hi`, o início recua (antes ficava curto).
new_start, new_end = fit_window(float(data["start_s"]), float(data["end_s"]), lo, hi, min_s, max_s, keep="start")
if new_end - new_start < min(10.0, min_s): # resposta incoerente: fica com o candidato da heurística
new_start, new_end = start_s, end_s
return Verdict(
keep=bool(data["keep"]), score=max(0.0, min(10.0, float(data["score"]))),
start_s=round(new_start, 2), end_s=round(new_end, 2),
title=str(data["title"]).strip()[:100], caption=str(data["caption"]).strip()[:600],
reason=str(data["reason"]).strip()[:300], model=model,
hashtags=tuple(str(t).strip()[:40] for t in (data.get("hashtags") or [])[:6] if str(t).strip()),
)
# ---------------------------------------------------------------- executáveis das CLIs
def find_codex() -> list[str] | None:
"""Comando do Codex. No Windows o npm instala `codex.cmd` (lote não roda sem shell e escapa mal argumentos):
como no painel (agents.ts), rodamos o `codex.js` do pacote direto pelo Node."""
env = os.environ.get("CODEX_BIN")
if env:
return [shutil.which("node") or "node", env] if env.endswith(".js") else [env]
exe = shutil.which("codex.exe") if sys.platform == "win32" else shutil.which("codex")
if exe:
return [exe]
cmd = shutil.which("codex.cmd") or shutil.which("codex")
node = shutil.which("node")
if cmd and node:
js = Path(cmd).parent / "node_modules" / "@openai" / "codex" / "bin" / "codex.js"
if js.is_file():
return [node, str(js)]
return None
def find_claude() -> list[str] | None:
env = os.environ.get("CLAUDE_BIN")
if env:
return [env]
exe = shutil.which("claude.exe") if sys.platform == "win32" else shutil.which("claude")
return [exe] if exe else None
def codex_models(cache: Path | None = None) -> list[dict]:
"""Modelos que o Codex lista para esta conta (cache que a própria CLI mantém)."""
cache = cache or Path.home() / ".codex" / "models_cache.json"
try:
data = json.loads(cache.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError):
return [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
out = []
for m in data.get("models", []):
if isinstance(m, dict) and m.get("slug") and m.get("visibility", "list") == "list":
out.append({"id": m["slug"], "label": m.get("display_name") or m["slug"], "description": m.get("description", "")})
return out or [{"id": DEFAULT_MODELS["codex"], "label": DEFAULT_MODELS["codex"]}]
# ---------------------------------------------------------------- IA
class Judge:
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = ""):
self.provider = provider if provider in PROVIDERS else "codex"
self.model = model or DEFAULT_MODELS.get(self.provider, "")
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor.
self.analyst_model = analyst_model
self.workdir = workdir
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None:
if provider not in PROVIDERS:
raise JudgeError(f"provedor precisa ser um de {', '.join(PROVIDERS)}")
self.provider = provider
self.model = model.strip() or DEFAULT_MODELS.get(provider, "")
if analyst_model is not None:
self.analyst_model = analyst_model.strip()
@property
def enabled(self) -> bool:
return self.provider in ("codex", "claude")
def command(self) -> list[str] | None:
return find_codex() if self.provider == "codex" else find_claude() if self.provider == "claude" else None
def describe(self) -> dict:
cmd = self.command() if self.enabled else None
return {"provider": self.provider, "model": self.model if self.enabled else None,
"analystModel": (self.analyst_model or self.model) if self.enabled else None,
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None}
def models(self) -> dict:
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "defaults": DEFAULT_MODELS}
# ---------- usos
def analyze(self, prompt: str, images: list[Path]) -> dict:
"""1º juiz (ANALISTA): o que aconteceu, cruzando tela + fala + chat. Não decide nem escreve título."""
data = self.ask(ANALYST_SYSTEM, prompt, ANALYSIS_SCHEMA, images, model=self.analyst_model or self.model)
missing = [k for k in ANALYSIS_SCHEMA["required"] if k not in data]
if missing:
raise JudgeError(f"análise sem os campos {missing}")
data["confidence"] = max(0.0, min(1.0, float(data["confidence"])))
return data
def judge(self, prompt: str, start_s: float, end_s: float, images: list[Path] | None = None, *,
lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
max_s: float = DEFAULT_MAX_S) -> Verdict:
data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or [])
return _clean(data, start_s, end_s, f"{self.provider}:{self.model}", lo, hi, min_s, max_s)
def scan(self, prompt: str, images: list[Path]) -> dict:
data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images)
if not isinstance(data.get("moments"), list):
raise JudgeError("varredura sem a lista de momentos")
return data
def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict:
prompt = f"Categoria/jogo da live: {name}\nTítulo da live (pista extra): {live_title or '(nenhum)'}\n"
if notes:
prompt += "Pedidos do usuário (respeite):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
prompt += "Pesquise e devolva o perfil do jogo."
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S)
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> dict:
"""Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro
mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior."""
prompt = f"Jogo: {name}\nPerfil ATUAL:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
if section in PROFILE_SECTIONS:
prompt += f"SEÇÃO em foco: {section} ({PROFILE_SECTIONS[section]})\n"
if history:
prompt += "Conversa até aqui:\n" + "\n".join(
f"{'Usuário' if h.get('role') == 'user' else 'IA'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
prompt += f"PEDIDO do usuário:\n{instruction}\n\nDevolva o perfil completo atualizado e o reply."
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S)
def detect_cam(self, images: list[Path]) -> dict:
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images)
# ---------- execução
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
timeout: int = TIMEOUT_S, model: str | None = None) -> dict:
model = model or self.model
if self.provider == "codex":
return self._codex(system, prompt, schema, images, search, timeout, model)
if self.provider == "claude":
return self._claude(system, prompt, schema, images, search, timeout, model)
raise JudgeError("IA desligada")
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int) -> subprocess.CompletedProcess:
try:
result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd,
creationflags=NO_WINDOW)
except subprocess.TimeoutExpired as exc:
raise JudgeError(f"a CLI passou de {timeout} s") from exc
except OSError as exc:
raise JudgeError(f"não consegui rodar a CLI: {exc}") from exc
if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-2:]
raise JudgeError(f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}")
return result
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_codex()
if not cmd:
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)")
self.workdir.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(dir=self.workdir) as tmp:
schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json"
schema_file.write_text(json.dumps(schema), encoding="utf-8")
image_args = [arg for img in images for arg in ("-i", str(Path(img).resolve()))]
lean = codex_lean_overrides(search)
if search:
stdin = system + "\n\n---\n\n" + prompt
else:
# Sem ferramentas, o texto do juiz faz o papel das instruções de base do Codex (como o
# --system-prompt do Claude). String literal do TOML ('...'): o caminho do Windows não é escapado.
instructions = Path(tmp) / "instructions.md"
instructions.write_text(system, encoding="utf-8")
lean += ["-c", f"model_instructions_file='{instructions}'"]
stdin = prompt
# `--search` é opção global (antes de `exec`). Cada imagem com seu `-i`; o "-" (prompt pela entrada
# padrão) vem depois de uma opção de valor único para não ser lido como mais uma imagem.
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral",
"--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args,
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
self._run(args, stdin, Path(tmp), timeout)
try:
return json.loads(out.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
raise JudgeError("o Codex não devolveu o JSON pedido") from exc
def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
cmd = find_claude()
if not cmd:
raise JudgeError("Claude Code CLI não encontrado")
self.workdir.mkdir(parents=True, exist_ok=True)
tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else [])
extra: list[str] = []
if images:
# O Claude vê imagem lendo o arquivo (ferramenta Read): liberamos só a pasta das imagens.
for folder in sorted({str(Path(i).resolve().parent) for i in images}):
extra += ["--add-dir", folder]
prompt += "\n\nImagens (leia cada uma com a ferramenta Read, na ordem):\n" + "\n".join(
str(Path(i).resolve()) for i in images)
args = [*cmd, "-p", "--model", model, "--output-format", "json", "--json-schema", json.dumps(schema),
"--tools", ",".join(tools), *(["--allowedTools", ",".join(tools)] if tools else []), *extra,
# --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s).
"--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local",
"--system-prompt", system]
result = self._run(args, prompt, self.workdir, timeout)
try:
envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu JSON") from exc
if envelope.get("is_error"):
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
data = envelope.get("structured_output")
if not isinstance(data, dict):
try:
data = json.loads(envelope.get("result") or "")
except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu o JSON pedido") from exc
return data
def analysis_block(analysis: dict) -> str:
"""Análise do 1º juiz no formato que o editor lê."""
return "Análise do ANALISTA (cruzou tela, fala e chat):\n" + json.dumps(analysis, ensure_ascii=False, indent=1)