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:
+226
-40
@@ -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]]:
|
||||
|
||||
Reference in New Issue
Block a user