@danhachuel/thunderbolt 0.5.40 → 0.5.42

package/app/main.py

@@ -107,6 +107,7 @@ from hermes_ui.thumbnails import (
 from hermes_ui.draft_video import DRAFT_SETTING_SECTIONS, missing_content_fields, missing_setting_sections, normalise_saved_script, setting_widget_suffixes
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_thumbnail_prompt, generate_title_and_keywords, generate_topic_for_channel, generate_video_description, generate_video_keywords, generate_video_update_metadata
 from hermes_ui.media_generation import MediaGenerationError, format_media_generation_error, generate_image_for_card, generate_video_for_card
+from hermes_ui.growth_youtube import list_analyses, run_audit
 from hermes_ui.canva_auth import authorization_url, create_pkce_pair, create_state, exchange_code
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
 from integrations.tiktok_public import fetch_public_tiktok_profile, normalize_tiktok_reference
@@ -1442,6 +1443,127 @@ def render_home_update_controls() -> None:
                 st.rerun()
 
 
+def _growth_score_color(score: float) -> str:
+    if score <= 30:
+        return "#ef4444"
+    if score < 70:
+        return "#f59e0b"
+    return "#22c55e"
+
+
+def _growth_channel_metrics(channel: dict[str, Any]) -> tuple[list[dict[str, Any]], float]:
+    """Calculate transparent local growth notes without fabricating Studio metrics."""
+    channel_id = str(channel.get("id") or "")
+    tasks = [item for item in read_json("tasks.json", []) if isinstance(item, dict) and str(item.get("channel_id") or "") == channel_id]
+    completed = [item for item in tasks if str(item.get("state") or item.get("status") or "").lower() == "done"]
+    with_thumbnail = [item for item in tasks if str(item.get("thumbnail_path") or (item.get("artifacts") or {}).get("thumbnail") or "").strip()]
+    with_title = [item for item in tasks if str(item.get("title") or "").strip()]
+    subscriber_count = channel.get("subscriber_count")
+    view_count = channel.get("view_count")
+    video_count = channel.get("video_count")
+
+    def number(value: Any) -> float | None:
+        try:
+            return float(value) if value is not None and str(value).strip() else None
+        except (TypeError, ValueError):
+            return None
+
+    subscribers, views, videos = number(subscriber_count), number(view_count), number(video_count)
+    demand = 70 if views is not None and views >= 1_000_000 else 55 if views is not None and views >= 100_000 else 50
+    thumbnail = round((len(with_thumbnail) / len(tasks)) * 100) if tasks else 50
+    title = round((len(with_title) / len(tasks)) * 100) if tasks else 50
+    conversion = round(min(100, (subscribers / views) * 10000)) if subscribers is not None and views and views > 0 else 50
+    cadence = round(min(100, len(tasks) * 12.5)) if tasks else 50
+    metrics = [
+        {"label": "Demanda validada", "score": demand, "value": f"{views:,.0f} visualizações" if views is not None else "Sem dados de visualizações", "source": "Canal YouTube" if views is not None else "Requer dados do canal"},
+        {"label": "Qualidade da thumbnail", "score": thumbnail, "value": f"{len(with_thumbnail)}/{len(tasks)} tarefas com thumbnail" if tasks else "Sem tarefas analisadas", "source": "Artefactos locais"},
+        {"label": "Qualidade do título", "score": title, "value": f"{len(with_title)}/{len(tasks)} tarefas com título" if tasks else "Sem tarefas analisadas", "source": "Artefactos locais"},
+        {"label": "Hook — retenção inicial", "score": 50, "value": "Sem dados de retenção", "source": "Requer YouTube Studio"},
+        {"label": "Ritmo e edição", "score": 50, "value": "Sem gráfico de retenção", "source": "Requer YouTube Studio"},
+        {"label": "Origem do tráfego", "score": 50, "value": "Sem distribuição de tráfego", "source": "Requer YouTube Studio"},
+        {"label": "Conversão em inscritos", "score": conversion, "value": f"{subscribers:,.0f} inscritos / {views:,.0f} visualizações" if subscribers is not None and views is not None else "Sem dados de inscritos e visualizações", "source": "Canal YouTube" if subscribers is not None and views is not None else "Requer dados do canal"},
+        {"label": "Cadência de publicação", "score": cadence, "value": f"{len(tasks)} tarefas locais" if tasks else "Sem tarefas locais", "source": "Pipeline local"},
+    ]
+    available = [metric["score"] for metric in metrics if metric["source"] not in {"Requer YouTube Studio", "Requer dados do canal"}]
+    overall = round(sum(available) / len(available)) if available else 50
+    return metrics, overall
+
+
+def render_growth_youtube():
+    st.title("Analista Growth Youtube")
+    st.caption("Auditoria pública baseada nos 3 pilares críticos e nas métricas secundárias do agente Growth.")
+    channels = [item for item in read_json("channels.json", []) if isinstance(item, dict) and item.get("active", True) and is_youtube_channel_record(item)]
+    if not channels:
+        st.info("Cadastre pelo menos um canal YouTube em Canais YouTube para iniciar a análise.")
+        return
+    selector_col, action_col = st.columns([1.05, 1.15], gap="small")
+    with selector_col:
+        selected = st.selectbox("Canal a analisar", channels, format_func=lambda item: str(item.get("name") or "Canal sem nome"), key="growth_youtube_channel")
+    with action_col:
+        st.write("")
+        analyse_clicked = st.button("ANALISAR CANAL", type="primary", use_container_width=True, key="growth_youtube_analyse")
+    if analyse_clicked:
+        settings = read_json("settings.json", {})
+        llm_settings, _ = ensure_llm_provider_cards(settings)
+        vision_card = next((card for card in llm_settings.get(LLM_CARDS_KEY, []) if isinstance(card, dict) and card.get("provider") == "nvidia_nim_paligemma" and card.get("enabled", True)), None)
+        with st.status("A preparar a análise pública…", expanded=True) as status:
+            try:
+                record = run_audit(selected, settings, vision_card=vision_card, progress=st.write)
+                st.session_state["growth_last_analysis_code"] = record["code"]
+                status.update(label="Análise concluída", state="complete")
+            except Exception as exc:
+                status.update(label="Análise falhou", state="error")
+                st.error(str(exc)[:500])
+    records = list_analyses()
+    selected_record = next((item for item in reversed(records) if str(item.get("channel_id")) == str(selected.get("id"))), None)
+    if selected_record is None and records:
+        selected_record = records[-1]
+    metrics = selected_record.get("metrics", []) if selected_record else []
+    overall = int(selected_record.get("overall_score", 50)) if selected_record else 50
+    color = _growth_score_color(overall)
+    st.markdown(
+        f'<div style="border:1px solid #263447;border-radius:12px;padding:18px;margin:12px 0 20px;background:#101722;display:flex;align-items:center;justify-content:space-between;">'
+        f'<div><div style="font-size:13px;color:#94a3b8;text-transform:uppercase;letter-spacing:.08em;">Nota geral do canal</div><div style="font-size:18px;font-weight:700;margin-top:5px;">{str(selected.get("name") or "Canal")}</div></div>'
+        f'<div style="font-size:42px;font-weight:800;color:{color};line-height:1;">{overall}<span style="font-size:16px;color:#94a3b8;">/100</span></div></div>',
+        unsafe_allow_html=True,
+    )
+    if selected_record and selected_record.get("report_path"):
+        report_path = Path(str(selected_record["report_path"]))
+        if report_path.is_file():
+            st.download_button("BAIXAR ANALISE COMPLETA", report_path.read_bytes(), file_name=report_path.name, mime="text/markdown", key=f"growth_download_{selected_record['code']}")
+    st.subheader("Dashboard de Growth")
+    st.caption("Vermelho: 0–30 · Amarelo: 31–69 · Verde: 70–100. Clique em ANALISAR CANAL para recolher dados públicos actualizados.")
+    for row_start in range(0, len(metrics), 4):
+        cols = st.columns(4, gap="small")
+        for col, metric in zip(cols, metrics[row_start:row_start + 4]):
+            with col:
+                score = metric["score"]
+                st.markdown(
+                    f'<div style="min-height:142px;border:1px solid #263447;border-radius:10px;padding:14px;background:#0d141e;">'
+                    f'<div style="font-size:13px;color:#cbd5e1;min-height:34px;">{metric["label"]}</div>'
+                    f'<div style="font-size:30px;font-weight:800;color:{_growth_score_color(score)};">{score}<span style="font-size:13px;color:#94a3b8;">/100</span></div>'
+                    f'<div style="font-size:12px;color:#e2e8f0;margin-top:5px;">{metric["value"]}</div>'
+                    f'<div style="font-size:11px;color:#64748b;margin-top:5px;">{metric.get("diagnosis", "")[:100]}</div></div>',
+                    unsafe_allow_html=True,
+                )
+    st.divider()
+    history_tab, dashboard_tab = st.tabs(["Últimas análises", "Leitura estratégica"])
+    with dashboard_tab:
+        st.write("Priorize primeiro as métricas abaixo de 70. Thumbnail + Título devem ser optimizados antes de alterações de conteúdo; Hook, Ritmo e Tráfego ficam pendentes de dados do YouTube Studio quando não houver dados públicos.")
+    with history_tab:
+        if not records:
+            st.info("Ainda não existem análises guardadas.")
+        for record in reversed(records[-20:]):
+            row = st.columns([2, 1, 2, 1, 1.4])
+            row[0].write(f"**{record.get('channel_name', 'Canal')}**")
+            row[1].write(str(record.get("platform", "YouTube")))
+            row[2].caption(str(record.get("code", "")))
+            row[3].write(f"{record.get('overall_score', 0)}/100")
+            report_path = Path(str(record.get("report_path") or ""))
+            if report_path.is_file():
+                row[4].download_button("Análise", report_path.read_bytes(), file_name=report_path.name, mime="text/markdown", key=f"growth_history_{record.get('code')}")
+
+
 def render_dashboard():
     ui_language = current_ui_language()
     st.title("Thunderbolt")
@@ -8668,7 +8790,7 @@ def main():
         "Motion Control": lambda: render_motion_control(read_json("settings.json", {})),
         "UGC Products": lambda: render_ugc_products(read_json("settings.json", {})),
         "Redes Sociais": lambda: render_edit_placeholder("Redes Sociais", "Área reservada para a futura funcionalidade de redes sociais."),
-        "Analista Growth Youtube": lambda: render_edit_placeholder("Analista Growth Youtube", ""),
+        "Analista Growth Youtube": render_growth_youtube,
         "Analista Growth Tiktok": lambda: render_edit_placeholder("Analista Growth Tiktok", ""),
         "Analista Growth Instagram": lambda: render_edit_placeholder("Analista Growth Instagram", ""),
         "Analista Facebook Pages": lambda: render_edit_placeholder("Analista Facebook Pages", ""),

package/hermes_ui/growth_youtube.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import base64
+import json
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+import requests
+
+from .llm_providers import ensure_llm_provider_cards
+from .provider_routing import ProviderRoutingError, route_llm_json
+from .storage import STORAGE, read_json, write_json
+
+ANALYSES_FILENAME = "youtube_growth_analyses.json"
+ANALYSES_DIR = STORAGE / "growth" / "youtube"
+AGENT_METRICS = (
+    "Demanda validada", "Qualidade da thumbnail", "Qualidade do título",
+    "Hook — retenção inicial", "Ritmo e edição", "Origem do tráfego",
+    "Conversão em inscritos", "Cadência de publicação",
+)
+
+
+def analysis_code(now: datetime | None = None) -> str:
+    moment = now or datetime.now(timezone.utc)
+    return f"GYA-{moment.strftime('%Y%m%d-%H%M%S')}-{uuid.uuid4().hex[:6].upper()}"
+
+
+def _score_color(score: int | float) -> str:
+    return "red" if score <= 30 else "yellow" if score < 70 else "green"
+
+
+def _safe_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value or default)
+    except (TypeError, ValueError):
+        return default
+
+
+def _public_videos(channel_url: str, limit: int = 10) -> list[dict[str, Any]]:
+    try:
+        import yt_dlp
+    except ImportError as exc:
+        raise RuntimeError("yt-dlp não está instalado. Instale as dependências do Thunderbolt.") from exc
+    options = {"quiet": True, "skip_download": True, "extract_flat": True, "playlistend": limit, "noplaylist": False}
+    with yt_dlp.YoutubeDL(options) as downloader:
+        info = downloader.extract_info(channel_url, download=False)
+    entries = info.get("entries") if isinstance(info, Mapping) else []
+    videos: list[dict[str, Any]] = []
+    for item in entries or []:
+        if not isinstance(item, Mapping):
+            continue
+        video_id = str(item.get("id") or "").strip()
+        if not video_id:
+            continue
+        videos.append({
+            "id": video_id,
+            "title": str(item.get("title") or "Sem título").strip(),
+            "url": str(item.get("webpage_url") or f"https://www.youtube.com/watch?v={video_id}"),
+            "thumbnail_url": str(item.get("thumbnail") or f"https://i.ytimg.com/vi/{video_id}/maxresdefault.jpg"),
+            "upload_date": str(item.get("upload_date") or ""),
+            "duration": _safe_int(item.get("duration")),
+            "view_count": _safe_int(item.get("view_count")),
+        })
+    return videos[:limit]
+
+
+def _download_thumbnail(video: Mapping[str, Any], directory: Path) -> str:
+    directory.mkdir(parents=True, exist_ok=True)
+    destination = directory / f"{video['id']}.jpg"
+    if not destination.exists():
+        response = requests.get(str(video.get("thumbnail_url") or ""), timeout=30)
+        response.raise_for_status()
+        destination.write_bytes(response.content)
+    return str(destination)
+
+
+def _transcript(video_id: str) -> tuple[str, str]:
+    try:
+        from youtube_transcript_api import YouTubeTranscriptApi
+    except ImportError:
+        return "", "ferramenta youtube-transcript-api não instalada"
+    try:
+        api = YouTubeTranscriptApi()
+        fetched = api.fetch(video_id)
+        text = " ".join(str(item.text if hasattr(item, "text") else item.get("text", "")) for item in fetched)
+        return text.strip(), "disponível" if text.strip() else "vazia"
+    except Exception as exc:
+        return "", str(exc)[:180]
+
+
+def _title_score(title: str) -> tuple[int, str]:
+    words = re.findall(r"[\wÀ-ÿ'-]+", title, flags=re.UNICODE)
+    lower = title.lower()
+    points = 20
+    if 3 <= len(words) <= 12: points += 20
+    if any(token in lower for token in ("como", "por que", "why", "how", "what", "segredo", "mistério", "mistério")): points += 20
+    if re.search(r"\d", title): points += 15
+    if any(token in lower for token in ("novo", "incrível", "proven", "explosive", "urgente", "fatal")): points += 10
+    if len(title) <= 70: points += 15
+    return min(100, points), "Curiosidade, clareza, keyword inicial e uso de números avaliados heurísticamente."
+
+
+def _transcript_score(text: str) -> tuple[int, str]:
+    if not text:
+        return 50, "Sem transcrição pública disponível; não foi inferida retenção."
+    lower = text.lower()
+    score = 45
+    if len(text) >= 400: score += 15
+    if any(token in lower[:1800] for token in ("hoje", "neste vídeo", "today", "in this video")): score += 15
+    if any(token in lower for token in ("inscreva", "subscribe", "comente", "comment")): score += 15
+    if text.count(".") >= 20: score += 10
+    return min(100, score), "Hook, clareza de abertura, CTA e cadência textual avaliados; retenção real requer YouTube Studio."
+
+
+def _analyse_transcript_with_llm(text: str, settings: Mapping[str, Any]) -> tuple[int, str]:
+    if not text:
+        return _transcript_score(text)
+    try:
+        result = route_llm_json(
+            settings,
+            "You are a YouTube Growth Auditor. Return JSON only with score (0-100), diagnosis, hook, pacing, cta. Do not invent retention percentages.",
+            "Analyse this transcript against the Growth Auditor criteria. Focus on the first 30 seconds, pattern interrupts, clarity and CTA.\n\n" + text[:14000],
+        )
+        payload = result.payload
+        choices = payload.get("choices") if isinstance(payload, Mapping) else []
+        content = choices[0].get("message", {}).get("content", "") if choices and isinstance(choices[0], Mapping) else ""
+        match = re.search(r"\{.*\}", str(content), flags=re.S)
+        parsed = json.loads(match.group(0)) if match else {}
+        score = max(0, min(100, _safe_int(parsed.get("score"), _transcript_score(text)[0])))
+        diagnosis = str(parsed.get("diagnosis") or _transcript_score(text)[1])[:500]
+        return score, diagnosis
+    except (ProviderRoutingError, ValueError, TypeError, KeyError):
+        return _transcript_score(text)
+
+
+def _vision_prompt(video: Mapping[str, Any]) -> str:
+    return ("Analyse this YouTube thumbnail for a Growth audit. Return concise JSON with score (0-100), "
+            "contrast, mobile_readability, text_words, hierarchy, emotion, overlap_risk, diagnosis. "
+            "Use the agent criteria: high contrast, max three words, clear subject, readable at 5-inch size. "
+            f"Video title: {video.get('title', '')}")
+
+
+def analyse_thumbnail_with_paligemma(path: str, card: Mapping[str, Any]) -> dict[str, Any]:
+    key = str(card.get("api_key") or "").strip()
+    base = str(card.get("base_url") or "https://integrate.api.nvidia.com/v1").rstrip("/")
+    model = str(card.get("model") or "google/paligemma").strip()
+    if not key:
+        return {"score": 50, "diagnosis": "API key NVIDIA NIM Paligemma não configurada.", "status": "sem_dados"}
+    data = base64.b64encode(Path(path).read_bytes()).decode("ascii")
+    payload = {"model": model, "messages": [{"role": "user", "content": [
+        {"type": "text", "text": "Evaluate this thumbnail for YouTube Growth. Return JSON with score, diagnosis, contrast, mobile_readability, text_words, hierarchy, emotion, overlap_risk."},
+        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{data}"}},
+    ]}], "max_tokens": 500, "temperature": 0.1}
+    response = requests.post(f"{base}/chat/completions", headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"}, json=payload, timeout=120)
+    response.raise_for_status()
+    content = response.json().get("choices", [{}])[0].get("message", {}).get("content", "")
+    match = re.search(r"\{.*\}", str(content), flags=re.S)
+    parsed = json.loads(match.group(0)) if match else {"diagnosis": str(content)[:1000]}
+    parsed["score"] = max(0, min(100, _safe_int(parsed.get("score"), 50)))
+    parsed["status"] = "analisado"
+    return parsed
+
+
+def _report_markdown(record: Mapping[str, Any]) -> str:
+    lines = [f"# CHANNEL AUDIT REPORT: {record.get('channel_name', 'Canal')}", "", f"- Código: `{record.get('code')}`", f"- Plataforma: YouTube", f"- Data: {record.get('created_at')}", f"- Nota geral: **{record.get('overall_score', 0)}/100**", "", "## Diagnóstico por métrica", "", "| Métrica | Nota | Evidência | Diagnóstico |", "|---|---:|---|---|"]
+    for metric in record.get("metrics", []):
+        lines.append(f"| {metric['label']} | {metric['score']}/100 | {metric['value']} | {metric['diagnosis']} |")
+    lines += ["", "## Últimos 10 vídeos", "", "| Título | Visualizações | Thumbnail | Transcrição | Nota do título |", "|---|---:|---|---|---:|"]
+    for video in record.get("videos", []):
+        lines.append(f"| {video.get('title', '').replace('|', '/')} | {video.get('view_count', 0):,} | {video.get('thumbnail_status', '')} | {video.get('transcript_status', '')} | {video.get('title_score', 0)}/100 |")
+    lines += ["", "## Top 3 prioridades", "", "1. Melhorar primeiro thumbnails e títulos abaixo de 70, aumentando contraste e reduzindo texto.", "2. Reforçar o hook inicial com o resultado ou promessa nos primeiros segundos.", "3. Introduzir CTA contextual e pattern interrupts ao longo do vídeo.", "", "## Limitações", "", "CTR, retenção real, origem de tráfego, RPM e horas de visualização exigem dados autorizados do YouTube Studio e não são inventados a partir da página pública."]
+    return "\n".join(lines) + "\n"
+
+
+def run_audit(channel: Mapping[str, Any], settings: Mapping[str, Any], *, vision_card: Mapping[str, Any] | None = None, progress: Callable[[str], None] | None = None) -> dict[str, Any]:
+    code = analysis_code()
+    root = ANALYSES_DIR / code
+    root.mkdir(parents=True, exist_ok=True)
+    notify = progress or (lambda _message: None)
+    channel_url = str(channel.get("url") or channel.get("handle") or "").strip()
+    if not channel_url:
+        raise RuntimeError("O canal seleccionado não tem URL pública ou handle YouTube.")
+    notify("A buscar o canal e os 10 vídeos mais recentes…")
+    videos = _public_videos(channel_url, 10)
+    if not videos:
+        raise RuntimeError("Não foram encontrados vídeos públicos no canal seleccionado.")
+    title_scores: list[int] = []
+    transcript_scores: list[int] = []
+    for index, video in enumerate(videos, 1):
+        notify(f"A analisar vídeo {index}/{len(videos)}…")
+        video["thumbnail_path"] = _download_thumbnail(video, root / "thumbnails")
+        video["thumbnail_status"] = "baixada"
+        text, status = _transcript(str(video["id"]))
+        video["transcript_status"] = status
+        video["transcript_path"] = str(root / "transcripts" / f"{video['id']}.txt")
+        Path(video["transcript_path"]).parent.mkdir(parents=True, exist_ok=True)
+        Path(video["transcript_path"]).write_text(text, encoding="utf-8")
+        video["title_score"], video["title_diagnosis"] = _title_score(video["title"])
+        video["transcript_score"], video["transcript_diagnosis"] = _analyse_transcript_with_llm(text, settings)
+        title_scores.append(video["title_score"])
+        transcript_scores.append(video["transcript_score"])
+        if vision_card:
+            try: video["vision"] = analyse_thumbnail_with_paligemma(video["thumbnail_path"], vision_card)
+            except Exception as exc: video["vision"] = {"score": 50, "status": "erro", "diagnosis": str(exc)[:220]}
+        else: video["vision"] = {"score": 50, "status": "sem_dados", "diagnosis": "Provider Paligemma não configurado."}
+    thumb_scores = [int((video.get("vision") or {}).get("score", 50)) for video in videos]
+    metrics = [
+        {"label": "Demanda validada", "score": 50, "value": f"{len(videos)} vídeos públicos", "diagnosis": "Amostra pública recolhida; volume de pesquisa/concorrência não disponível."},
+        {"label": "Qualidade da thumbnail", "score": round(sum(thumb_scores) / len(thumb_scores)), "value": f"{len(videos)} thumbnails analisadas", "diagnosis": "Avaliação Paligemma/NIM ou sem dados quando não configurado."},
+        {"label": "Qualidade do título", "score": round(sum(title_scores) / len(title_scores)), "value": f"{len(videos)} títulos analisados", "diagnosis": "Curiosidade, clareza, urgência, palavras-chave e números."},
+        {"label": "Hook — retenção inicial", "score": round(sum(transcript_scores) / len(transcript_scores)), "value": "Análise textual das aberturas", "diagnosis": "Inferência textual; retenção percentual real não está disponível."},
+        {"label": "Ritmo e edição", "score": 50, "value": "Sem vídeo/curva de retenção", "diagnosis": "Requer gráfico de retenção do YouTube Studio."},
+        {"label": "Origem do tráfego", "score": 50, "value": "Sem dados públicos", "diagnosis": "Requer YouTube Studio."},
+        {"label": "Conversão em inscritos", "score": 50, "value": "Sem inscritos por vídeo", "diagnosis": "Requer Analytics autorizado."},
+        {"label": "Cadência de publicação", "score": 50, "value": "Datas públicas recolhidas", "diagnosis": "Cadência detalhada será calculada quando datas válidas forem fornecidas."},
+    ]
+    overall = round(sum(metric["score"] for metric in metrics) / len(metrics))
+    record = {"code": code, "channel_id": str(channel.get("id") or ""), "channel_name": str(channel.get("name") or "Canal"), "platform": "YouTube", "created_at": datetime.now(timezone.utc).isoformat(), "overall_score": overall, "score_color": _score_color(overall), "metrics": metrics, "videos": videos, "status": "completed"}
+    report_path = root / f"{code}.md"
+    report_path.write_text(_report_markdown(record), encoding="utf-8")
+    record["report_path"] = str(report_path)
+    analyses = read_json(ANALYSES_FILENAME, [])
+    if not isinstance(analyses, list): analyses = []
+    analyses.append(record)
+    write_json(ANALYSES_FILENAME, analyses[-100:])
+    return record
+
+
+def list_analyses() -> list[dict[str, Any]]:
+    value = read_json(ANALYSES_FILENAME, [])
+    return [dict(item) for item in value if isinstance(item, Mapping)] if isinstance(value, list) else []
+
+
+__all__ = ["AGENT_METRICS", "ANALYSES_DIR", "analysis_code", "analyse_thumbnail_with_paligemma", "list_analyses", "run_audit"]

package/hermes_ui/llm_providers.py

@@ -37,6 +37,7 @@ class LlmProviderDefinition:
     supports_model_discovery: bool = True
     extra_fields: tuple[str, ...] = ()
     description: str = ""
+    excluded_from_normal_pool: bool = False
 
 
 # Só estão aqui providers que o adaptador OpenAI-compatible existente consegue
@@ -50,6 +51,15 @@ LLM_PROVIDER_CATALOG: tuple[LlmProviderDefinition, ...] = (
         default_base_url=DEFAULT_NVIDIA_NIM_BASE_URL,
         description="OpenAI ou NVIDIA NIM através do protocolo OpenAI-compatible.",
     ),
+    LlmProviderDefinition(
+        "nvidia_nim_paligemma",
+        "OpenAI / NVIDIA NIM (Paligemma)",
+        show_base_url=True,
+        default_base_url="https://integrate.api.nvidia.com/v1",
+        supports_model_discovery=False,
+        excluded_from_normal_pool=True,
+        description="Provider exclusivo do Analista Growth YouTube para análise visual de thumbnails.",
+    ),
     LlmProviderDefinition("openrouter", "OpenRouter", default_base_url="https://openrouter.ai/api/v1"),
     LlmProviderDefinition("moonshot", "Moonshot / Kimi", default_base_url="https://api.moonshot.ai/v1"),
     LlmProviderDefinition("shengsuanyun", "Shengsuan Cloud", show_base_url=True),

package/hermes_ui/provider_routing.py

@@ -283,7 +283,9 @@ def enabled_cards(settings: Mapping[str, Any], pool: str) -> list[dict[str, Any]
         enabled = [
             (index, card)
             for index, card in enumerate(cards)
-            if bool(card.get("enabled", True)) and not bool(card.get("telegram_llm", False))
+            if bool(card.get("enabled", True))
+            and not bool(card.get("telegram_llm", False))
+            and not provider_definition(card.get("provider")).excluded_from_normal_pool
         ]
         enabled.sort(key=lambda pair: (int(pair[1].get("priority", 1)), pair[0]))
         return [card for _index, card in enabled]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.5.40",
+  "version": "0.5.42",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",

package/requirements.txt

@@ -15,6 +15,7 @@ mlxtend>=0.23,<1
 plotly>=5.18,<7
 seaborn>=0.13,<1
 yt-dlp>=2025.1.15,<2027
+youtube-transcript-api>=1.2.0,<2
 ytmusicapi>=1.12,<2
 pushtunes>=2.15,<3
 matplotlib>=3.7,<4