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