Clipador: subpáginas, jogos, idioma por canal e juiz com Gemini e IA reserva

- Clipador em subpáginas (Cortes, Sessões, Fontes, Jogos, Ajustes) com moldura comum, lista + diálogo
  dos cortes e submenu na barra lateral.
- Perfis de jogo (o que a IA sabe de cada jogo), parar pausa o monitor e idioma por fonte e por canal
  de publicação (migração v9: accounts.language).
- Juiz: Gemini CLI como terceiro provedor e IA reserva por chamada — se a IA escolhida cair por cota,
  login, chave ou rede, a próxima da ordem de Configurações → IA responde (com pausa da que caiu).
  Lê data/ai/settings.json e o cofre data/ai/vault.bin (DPAPI) escritos pelo painel; contrato em doc/ia.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 01:51:12 -03:00
co-authored by Claude Opus 5.5
parent 2d8b1a582d
commit 0567c7454a
55 changed files with 6514 additions and 2506 deletions
+226 -40
View File
@@ -23,7 +23,7 @@ from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable
from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context
from .judge import JudgeError, build_scan_prompt, game_context, output_language_note
from .scoring import fit_window
from .sources import parse_source
@@ -52,31 +52,79 @@ def game_id(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources")
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources", "aliases", "end_triggers")
# Teto de cada lista (o resto: 20). Missões ficam à parte (objetos, até 120).
LIST_LIMITS = {"aliases": 10, "end_triggers": 12}
MAX_MISSIONS = 120
MAX_MISSION_TRIGGERS = 8
# Sementes: perfis prontos que vêm com o repositório (ex.: GTA VI). Importados na subida só se o jogo não existe.
SEEDS_DIR = Path(__file__).resolve().parent / "seeds" / "games"
def _clean_text_list(values, limit: int, item_chars: int = 300) -> list[str]:
items, seen = [], set()
for item in values or []:
text = str(item or "").strip()[:item_chars]
if text and text.lower() not in seen:
seen.add(text.lower())
items.append(text)
return items[:limit]
def clean_missions(values) -> list[dict]:
"""Missões: nome obrigatório (sem repetir), capítulo, resumo e até 8 gatilhos de fim (até 200 caracteres cada)."""
out, seen = [], set()
for raw in values or []:
if not isinstance(raw, dict):
continue
name = str(raw.get("name") or "").strip()[:160]
if not name or name.lower() in seen:
continue
seen.add(name.lower())
out.append({
"name": name,
"chapter": str(raw.get("chapter") or "").strip()[:120],
"summary": str(raw.get("summary") or "").strip()[:500],
"completion_triggers": _clean_text_list(raw.get("completion_triggers"), MAX_MISSION_TRIGGERS, 200),
})
if len(out) >= MAX_MISSIONS:
break
return out
def clean_profile(raw: dict) -> dict:
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
"""Normaliza um perfil de jogo (vindo da IA, da tradução ou da edição à mão): textos aparados, listas sem
vazios/duplicados, missões validadas. Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some),
comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
items, seen = [], set()
for item in raw.get(key) or []:
text = str(item or "").strip()[:300]
if key == "hashtags":
text = to_tag(text) or ""
if key == "hashtags":
items, seen = [], set()
for item in raw.get(key) or []:
text = to_tag(str(item or "").strip()[:300]) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
continue
if text and text.lower() not in seen:
seen.add(text.lower())
items.append(text)
out[key] = items[:20]
out[key] = items[:20]
else:
out[key] = _clean_text_list(raw.get(key), LIST_LIMITS.get(key, 20))
out["missions"] = clean_missions(raw.get("missions"))
return out
def alias_ids(*profiles: dict | None) -> list[str]:
"""Ids normalizados dos outros nomes do jogo (das duas versões do perfil), sem repetir."""
ids: list[str] = []
for profile in profiles:
for alias in (profile or {}).get("aliases") or []:
gid = game_id(str(alias))
if gid != "desconhecido" and gid not in ids:
ids.append(gid)
return ids
class Intel:
def __init__(self, engine: "Engine"):
self.e = engine
@@ -91,6 +139,37 @@ class Intel:
for key in OPTION_DEFAULTS:
if f"opt_{key}" in saved:
self.opts[key] = json.loads(saved[f"opt_{key}"])
self.import_seeds()
# ---------------------------------------------------------------- sementes de jogos
def import_seeds(self, folder: Path | None = None) -> list[str]:
"""Importa os perfis de `seeds/games/*.json` ({name, aliases, researchedAt, sources, profileAi, profile}) que
ainda não existem no banco (por id ou alias). Nunca sobrescreve: o que você editou fica. Devolve os ids novos."""
added: list[str] = []
for path in sorted((folder or SEEDS_DIR).glob("*.json")):
try:
seed = json.loads(path.read_text(encoding="utf-8"))
name = str(seed.get("name") or "").strip()
if not name:
continue
ai = clean_profile({**(seed.get("profileAi") or {}), "name": name})
pt = clean_profile({**(seed.get("profile") or seed.get("profileAi") or {}), "name": name})
for profile in (ai, pt):
profile["aliases"] = profile["aliases"] or list(seed.get("aliases") or [])
profile["sources"] = profile["sources"] or list(seed.get("sources") or [])
gid = game_id(name)
if self.find_game(name) or any(self.find_game(a) for a in ai["aliases"]):
continue
self.e.db.run(
"INSERT INTO games (id, name, status, profile_json, profile_ai_json, aliases_json, model, researched_at,"
" translated_at) VALUES (?, ?, 'ready', ?, ?, ?, 'seed', ?, ?)",
gid, name[:120], json.dumps(pt, ensure_ascii=False), json.dumps(ai, ensure_ascii=False),
json.dumps(alias_ids(ai, pt)), seed.get("researchedAt") or now(), seed.get("researchedAt") or now())
added.append(gid)
log.info("jogo importado da semente %s: %s", path.name, name)
except (OSError, ValueError) as exc:
log.warning("semente de jogo %s inválida: %s", path.name, exc)
return added
# ---------------------------------------------------------------- opções (painel)
def set_options(self, values: dict) -> dict:
@@ -202,7 +281,7 @@ class Intel:
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
gid = game_id(name)
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
if not self.find_game(name):
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
def research_pending(self) -> None:
@@ -212,53 +291,142 @@ class Intel:
self.research(game["id"])
def research(self, gid: str) -> dict:
"""Pesquisa na web EM INGLÊS (missões e gatilhos inclusos) → versão da IA; depois traduz para português (a que
o painel mostra). Tradução falhou: as duas ficam em inglês e `error` explica (o jogo continua utilizável)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo")
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para pesquisar o jogo")
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
try:
profile = self.e.judge.research_game(game["name"], title, notes)
ai = clean_profile(self.e.judge.research_game(game["name"], title, notes))
model = self.e.judge.responder() # quem DE FATO respondeu (pode ter sido a IA reserva)
except (JudgeError, json.JSONDecodeError) as exc:
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
raise JudgeError(str(exc)) from exc
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?",
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid)
return profile
self.e.db.run("UPDATE games SET profile_ai_json = ?, model = ?, researched_at = ? WHERE id = ?",
json.dumps(ai, ensure_ascii=False), model, now(), gid)
pt, error = self._translated(ai, "pt-BR")
self._store(gid, pt=pt, ai=ai, translated=error is None, error=error)
return ai
def save_profile(self, gid: str, profile: dict) -> dict:
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready')."""
def _translated(self, profile: dict, target: str) -> tuple[dict, str | None]:
"""(perfil traduzido, None) ou (o próprio perfil, motivo) se a IA está desligada ou a tradução falhou."""
if not self.e.judge.enabled:
return profile, "IA desligada: a outra versão do perfil não foi atualizada"
try:
out = clean_profile(self.e.judge.translate_game(profile, target))
except (JudgeError, json.JSONDecodeError) as exc:
return profile, f"tradução falhou: {exc}"[:300]
# A tradução nunca mexe em nome, hashtags, fontes e outros nomes (a IA às vezes "traduz" o que não devia).
for key in ("name", "hashtags", "sources", "aliases"):
out[key] = profile.get(key) or out.get(key)
if len(out.get("missions") or []) != len(profile.get("missions") or []):
return profile, "tradução perdeu missões: a outra versão ficou igual à original"
return out, None
def _store(self, gid: str, *, pt: dict | None = None, ai: dict | None = None, translated: bool = False,
error: str | None = None, edited: bool = False, extra_sql: str = "", extra: tuple = ()) -> None:
"""Grava as versões que vieram (None = não mexe), os outros nomes (união das duas) e o estado."""
game = self.e.db.get("SELECT profile_json, profile_ai_json FROM games WHERE id = ?", gid) or {}
pt_now = pt if pt is not None else loads(game.get("profile_json"), None)
ai_now = ai if ai is not None else loads(game.get("profile_ai_json"), None)
self.e.db.run(
"UPDATE games SET status = 'ready', profile_json = ?, profile_ai_json = ?, aliases_json = ?, error = ?,"
" translated_at = CASE WHEN ? THEN ? ELSE translated_at END,"
" edited_at = CASE WHEN ? THEN ? ELSE edited_at END" + extra_sql + " WHERE id = ?",
json.dumps(pt_now, ensure_ascii=False) if pt_now is not None else None,
json.dumps(ai_now, ensure_ascii=False) if ai_now is not None else None,
json.dumps(alias_ids(ai_now, pt_now)), error, int(translated), now(), int(edited), now(), *extra, gid)
def save_profile(self, gid: str, profile: dict, lang: str = "pt") -> dict:
"""Grava a edição à mão na versão `lang` ("pt" = a que você lê; "en" = a da IA) e traduz para a outra. Com a IA
desligada, grava só essa e a outra fica como estava (`translatedAt` não muda: o painel avisa que está velha)."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
clean = clean_profile(profile)
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?",
json.dumps(clean, ensure_ascii=False), now(), gid)
target = "en-US" if lang == "pt" else "pt-BR"
other, error = self._translated(clean, target)
translated = error is None
if lang == "pt":
self._store(gid, pt=clean, ai=other if translated else None, translated=translated, error=error, edited=True)
else:
self._store(gid, ai=clean, pt=other if translated else None, translated=translated, error=error, edited=True)
return clean
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
def translate(self, gid: str) -> dict:
"""Gera a versão da IA (inglês) a partir da portuguesa — para jogos de antes da v12."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA")
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]})
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para traduzir o perfil")
pt = loads(game["profile_json"], None)
if not pt:
raise JudgeError("o jogo ainda não tem perfil para traduzir")
ai, error = self._translated(clean_profile(pt), "en-US")
if error:
raise JudgeError(error)
self._store(gid, ai=ai, translated=True)
return ai
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). Aplica na versão em inglês
(a da IA; jogo antigo sem ela: na portuguesa) e traduz para português. O pedido fica guardado e volta em toda
pesquisa. Devolve (perfil em português, resposta curta da IA em português)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para editar o perfil pela IA")
current = (loads(game.get("profile_ai_json"), None) or loads(game["profile_json"], None)
or clean_profile({"name": game["name"]}))
try:
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
model = self.e.judge.responder() # antes da tradução, que também passa pelo juiz
except json.JSONDecodeError as exc:
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
reply = str(data.get("reply") or "").strip()[:600]
profile = clean_profile(data)
ai = clean_profile(data)
pt, error = self._translated(ai, "pt-BR")
notes = loads(game.get("notes_json"), [])
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?,"
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False),
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid)
return profile, reply
self._store(gid, ai=ai, pt=pt, translated=error is None, error=error, edited=True,
extra_sql=", notes_json = ?, model = ?",
extra=(json.dumps(notes[-30:], ensure_ascii=False), model))
return pt, reply
def add_game(self, name: str, notes: str = "") -> str:
"""Cadastra um jogo pelo painel (antes só nascia da categoria da live) e pesquisa em segundo plano.
Já existe (pelo id ou por outro nome dele) → UserError 409."""
name = name.strip()[:120]
if not name:
raise ValueError("Diga o nome do jogo.")
existing = self.find_game(name)
if existing:
raise LookupError(f"“{existing['name']}” já está na lista.")
gid = game_id(name)
note_list = [{"text": notes.strip()[:1500], "at": now()}] if notes.strip() else []
self.e.db.run("INSERT INTO games (id, name, status, notes_json) VALUES (?, ?, 'pending', ?)",
gid, name, json.dumps(note_list, ensure_ascii=False))
if self.e.judge.enabled:
threading.Thread(target=self._research_quietly, args=(gid,), name=f"game-{gid}", daemon=True).start()
return gid
def _research_quietly(self, gid: str) -> None:
try:
self.research(gid)
except JudgeError as exc:
log.warning("pesquisa do jogo %s falhou: %s", gid, exc)
def delete_game(self, gid: str) -> None:
"""Apaga o jogo. Sessões não mudam; se o jogo voltar numa live, nasce de novo e é pesquisado."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
self.e.db.run("DELETE FROM games WHERE id = ?", gid)
def delete_note(self, gid: str, index: int) -> None:
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
@@ -270,11 +438,26 @@ class Intel:
notes.pop(index)
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
def profile(self, name: str) -> dict | None:
if not name:
def find_game(self, name: str) -> dict | None:
"""Linha do jogo pelo nome: id normalizado ou, se não achar, um jogo que tem esse nome entre os outros nomes."""
gid = game_id(name or "")
if not name or gid == "desconhecido":
return None
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name))
return loads(row["profile_json"], None) if row else None
row = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if row:
return row
# aliases_json é uma lista JSON de ids: procura o id entre aspas (LIKE barato, confere no Python).
for row in self.e.db.all("SELECT * FROM games WHERE aliases_json LIKE ?", f'%"{gid}"%'):
if gid in loads(row.get("aliases_json"), []):
return row
return None
def profile(self, name: str) -> dict | None:
"""Perfil que vai para a IA: a versão em inglês; jogo antigo, sem ela, usa a portuguesa."""
row = self.find_game(name)
if not row or row["status"] != "ready":
return None
return loads(row.get("profile_ai_json"), None) or loads(row["profile_json"], None)
def session_game(self, session: dict) -> tuple[str, dict | None]:
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
@@ -291,8 +474,11 @@ class Intel:
memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
return game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
text = game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed)
# Sessão em outro idioma (fonte gringa): o editor e a varredura escrevem título/legenda nesse idioma.
note = output_language_note(session.get("language") or self.e.settings.language)
return f"{text}\n{note}" if note else text
# ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]: