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:
@@ -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)
|
||||
Reference in New Issue
Block a user