"""Equipe de IA do Clipador (doc/clipador/EQUIPE-IA.md): quatro papéis, cada um com a sua IA. - **varredura** (`scan`): assiste a live por janelas e propõe momentos (e descreve a tela para a linha do tempo); - **analista** (`analyst`): diz O QUE aconteceu no trecho candidato (cruza tela, fala e chat); - **editor** (`editor`): decide se vira corte, escolhe o trecho e escreve título/legenda — não pode ser desligado; - **juiz** (`judge`): só texto, vê só o que vai no corte final e confere se ele tem CONTEXTO (começo, desfecho, funciona sozinho). Quem decide pelas respostas é o código (`context_judge.decide`). Cada papel tem provedor + modelo (+ esforço de raciocínio no Codex), liga/desliga e as **instruções do administrador** (texto extra somado às instruções padrão, que continuam no código). Gravado na tabela `settings` com a chave `judge.roles` (JSON). Sem essa chave (banco de antes), a configuração antiga vira a de todos os papéis: o provedor/modelo único de hoje vale para todos e o "modelo do analista" que já existia é respeitado. """ from __future__ import annotations import copy import json SETTINGS_KEY = "judge.roles" ROLES = ("scan", "analyst", "editor", "judge") ROLE_NAMES = {"scan": "Varredura", "analyst": "Analista", "editor": "Editor", "judge": "Juiz"} ROLE_PROVIDERS = ("codex", "claude", "gemini") # Esforço de raciocínio: só o Codex aceita (`model_reasoning_effort`). "" = padrão (low, o de sempre). EFFORTS = ("", "low", "medium", "high") # Imagens da varredura e do analista: mosaico 4×2 numa imagem só (novo), frames soltos (antigo) ou nenhuma. IMAGE_MODES = ("mosaic", "frames", "none") IMAGE_ROLES = ("scan", "analyst") EXTRA_MAX = 2000 # Perguntas sim/não do juiz (doc/clipador/PESQUISA-JUIZ.md §6). As críticas decidem; as outras só baixam a nota. CHECKS = ("setup", "payoff", "who_what", "standalone", "intelligible", "faithful", "strong_open") CHECK_NAMES = {"setup": "começo (setup)", "payoff": "desfecho", "who_what": "quem/o quê", "standalone": "funciona sozinho", "intelligible": "fala clara", "faithful": "título fiel", "strong_open": "abertura forte"} DEFAULT_CRITICAL = ("setup", "payoff", "standalone") DEFAULT_PENALTY = 0.5 def _role(provider: str, model: str = "", effort: str = "", enabled: bool = True) -> dict: return {"enabled": enabled, "provider": provider, "model": model, "effort": effort, "extra": ""} def default_roles(provider: str = "codex", model: str = "", analyst_model: str = "") -> dict: """Configuração de partida: todos os papéis na mesma IA (como era antes). O juiz pensa um pouco mais (esforço médio no Codex), como a pesquisa recomenda; os outros continuam no esforço baixo de sempre.""" provider = provider if provider in ROLE_PROVIDERS else "codex" roles = { "scan": _role(provider, model), "analyst": _role(provider, analyst_model or model), "editor": _role(provider, model), "judge": _role(provider, model, "medium" if provider == "codex" else ""), } roles["scan"]["images"] = "mosaic" roles["analyst"]["images"] = "mosaic" roles["judge"] |= {"critical": list(DEFAULT_CRITICAL), "allowFix": True, "allowContextLine": True, "penalty": DEFAULT_PENALTY} return roles def _text(value: object, limit: int) -> str: return str(value or "").replace("\r\n", "\n").strip()[:limit] def normalize_roles(raw: object, base: dict | None = None) -> dict: """Valida campo a campo sobre `base` (padrão: `default_roles()`). O que vier errado fica como estava. O editor nunca desliga (é quem decide se vira corte).""" roles = copy.deepcopy(base or default_roles()) if not isinstance(raw, dict): return roles for name in ROLES: item = raw.get(name) if not isinstance(item, dict): continue role = roles[name] if isinstance(item.get("enabled"), bool): role["enabled"] = item["enabled"] if item.get("provider") in ROLE_PROVIDERS: if item["provider"] != role["provider"] and "model" not in item: role["model"] = "" # trocou de provedor sem dizer o modelo: o padrão do provedor novo role["provider"] = item["provider"] if isinstance(item.get("model"), str): model = item["model"].strip()[:80] if all(c.isalnum() or c in "._:-" for c in model): role["model"] = model if item.get("effort") in EFFORTS: role["effort"] = item["effort"] if "extra" in item: role["extra"] = _text(item.get("extra"), EXTRA_MAX) if name in IMAGE_ROLES and item.get("images") in IMAGE_MODES: role["images"] = item["images"] if name == "judge": critical = item.get("critical") if isinstance(critical, list): role["critical"] = [c for c in CHECKS if c in critical] for key in ("allowFix", "allowContextLine"): if isinstance(item.get(key), bool): role[key] = item[key] penalty = item.get("penalty") if isinstance(penalty, (int, float)) and not isinstance(penalty, bool) and 0 <= penalty <= 3: role["penalty"] = float(penalty) roles["editor"]["enabled"] = True return roles def from_settings(saved: dict[str, str], provider: str, model: str) -> dict: """Papéis gravados (`judge.roles`) ou, sem eles, a MIGRAÇÃO da configuração antiga: `judge_provider`/ `judge_model` viram os de todos os papéis e `judge_analyst_model` (se havia) fica com o analista. `provider`/`model` = os valores iniciais do .env, para quando nem a antiga existe.""" legacy_provider = saved.get("judge_provider", provider) legacy_model = saved.get("judge_model", model) or "" base = default_roles(legacy_provider, legacy_model, saved.get("judge_analyst_model", "") or "") raw = saved.get(SETTINGS_KEY) if not raw: return base try: return normalize_roles(json.loads(raw), base) except ValueError: return base def admin_notes(role: dict, lang: str = "pt") -> str: """Bloco que vai DEPOIS das instruções padrão. Os juízes em inglês entendem português: o dono escreve como quiser.""" extra = (role or {}).get("extra", "").strip() if not extra: return "" title = ("Admin notes (may be written in Portuguese; when they conflict with the rules above, they win):" if lang == "en" else "Instruções do administrador (quando conflitarem com as regras acima, valem estas):") return f"\n\n{title}\n{extra}"