"""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)