Files
CenaForge/clipper/app/judge.py
T
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

641 lines
36 KiB
Python
Raw 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.
"""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)