@danhachuel/thunderbolt 0.4.19 → 0.4.21

package/app/main.py

@@ -45,6 +45,7 @@ from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_d
 from app.modules.niche_finder.summarizer import summarize_items
 from app.influencers_ui import render_ai_influencer_characters, render_ai_influencer_content, render_ai_influencers_api_status, render_motion_control, render_ugc_products
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
+from hermes_ui.thumbnail_blueprints import generate_thumbnail_blueprint, list_thumbnail_blueprint_documents, resolve_thumbnail_blueprint, save_thumbnail_blueprint, save_thumbnail_blueprint_pair, thumbnail_blueprint_catalog, thumbnail_blueprint_for_channel
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
 from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEditorError, change_speed, editor_manifest, extract_audio, list_edit_records as list_python_editor_records, list_generated_videos, list_scripts, list_video_files, read_script, remove_audio, replace_audio, resize_video, save_edit_record as save_python_editor_record, save_script, store_uploaded_asset, trim_video
 from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips, list_generated_videos as list_cut_generated_videos, list_runs as list_cut_runs, list_video_files as list_cut_video_files, manifest_bytes as cut_manifest_bytes, store_uploaded_video, zip_run as zip_cut_run
@@ -605,6 +606,17 @@ def render_channel_blueprint_panel(channel: dict, *, compact: bool = False) -> N
         st.info(f"**Blueprint utilizado pelo canal:** {summary['name']} · `{summary['id']}` · **Voz:** {voice} · **Idioma:** {video_language}")
 
 
+def render_channel_thumbnail_blueprint_panel(channel: dict, *, compact: bool = False) -> None:
+    document = thumbnail_blueprint_for_channel(channel)
+    name = str(document.get("name") or "SEM THUMBNAIL BLUEPRINT CONFIGURADO")
+    if name == "SEM THUMBNAIL BLUEPRINT CONFIGURADO":
+        st.warning("**SEM THUMBNAIL BLUEPRINT CONFIGURADO** · associe um Thumbnail Blueprint na aba Thumbnail Blueprints.")
+    elif compact:
+        st.caption(f"**Thumbnail Blueprint:** {name}")
+    else:
+        st.info(f"**Thumbnail Blueprint utilizado pelo canal:** {name} · apenas leitura")
+
+
 def creative_payload_from_result(channel: dict, topic: str, creative: dict, topic_source: str = "manual") -> dict[str, Any]:
     variant = creative.get("thumbnail_variant") or {}
     return {
@@ -620,6 +632,7 @@ def creative_payload_from_result(channel: dict, topic: str, creative: dict, topi
         "thumbnail_status": str(creative.get("thumbnail_status") or "prompt_ready"),
         "blueprint_id": str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or ""),
         "blueprint_name": str(channel_blueprint_summary(channel).get("name") or "SEM BLUEPRINT CONFIGURADO"),
+        "thumbnail_blueprint_id": str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or ""),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
         "ai_generation": {"creative": creative},
     }
@@ -839,11 +852,15 @@ def generate_thumbnail_for_ui(
     topic = str(topic or "").strip()
     if not topic:
         raise CreativeGenerationError("É necessário um tópico antes de gerar a thumbnail.")
+    script_blueprint = blueprint_for_channel(channel)
+    visual_blueprint = thumbnail_blueprint_for_channel(channel)
+    if visual_blueprint.get("content"):
+        script_blueprint = {**script_blueprint, "thumbnail_blueprint_rules": visual_blueprint.get("content", "")}
     variant = generate_thumbnail_prompt(
         settings,
         channel,
         topic,
-        blueprint=blueprint_for_channel(channel),
+        blueprint=script_blueprint,
         language=str(channel.get("language") or "Português"),
     )
     return {
@@ -1405,7 +1422,7 @@ def render_dashboard():
 def render_blueprints():
     st.title("Blueprints Youtube")
     st.caption(f"Biblioteca local lida directamente de `{BLUEPRINTS}`")
-    blueprint_tab, branding_tab = render_localized_tabs(["Blueprints", "Brandings"])
+    blueprint_tab = st.container()
     with blueprint_tab:
         st.subheader("Criar blueprint a partir de link")
         with st.form("create_blueprint_from_link"):
@@ -1474,42 +1491,115 @@ def render_blueprints():
             except Exception as exc:
                 with st.expander(f"Inválido — {path.stem}"):
                     st.error(str(exc))
-    with branding_tab:
-        st.subheader("Brandings completos")
-        st.caption(f"Brandings gerados ou importados da pasta `{BLUEPRINTS / 'brandings'}`")
-        branding_upload = st.file_uploader("Subir Branding JSON", type=["json"], key="branding_upload")
-        if branding_upload and st.button("Guardar Branding", type="secondary"):
-            try:
-                data = json.loads(branding_upload.getvalue().decode("utf-8"))
-                if not isinstance(data, dict):
-                    raise ValueError("O JSON raiz deve ser um objecto.")
-                target = BLUEPRINTS / "brandings" / (Path(branding_upload.name).stem.replace(" ", "-") + ".json")
-                target.parent.mkdir(parents=True, exist_ok=True)
-                atomic_write(target, data)
-                record_notification("branding_completed", f"Branding guardado: {target.stem}", "O Branding importado foi guardado no storage local.", metadata={"name": target.stem}, dedupe_key=f"branding:{target}:{target.stat().st_mtime_ns}")
-                st.success(f"Branding guardado em {target}")
-                st.rerun()
-            except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
-                st.error(f"Branding JSON inválido: {exc}")
-        branding_files = list_branding_files()
-        st.write(f"{len(branding_files)} branding(s) encontrado(s)")
-        branding_search = st.text_input("Pesquisar brandings", key="branding_search")
-        if not branding_files:
-            st.info("Ainda não existem brandings na pasta local.")
-        for path in branding_files:
-            if branding_search and branding_search.lower() not in path.name.lower():
-                continue
-            try:
-                data = load_blueprint_file(path)
-                title = data.get("name") or data.get("identity", {}).get("channel_name") or path.stem
-                with st.expander(f"{title} — {path.name}"):
-                    st.caption(f"Blueprint associado: {data.get('blueprint_id') or 'não associado'}")
-                    st.json(data)
-            except Exception as exc:
-                with st.expander(f"Inválido — {path.stem}"):
-                    st.error(str(exc))
 
 
+def render_youtube_brandings():
+    st.title("Brandings Youtube")
+    st.caption(f"Brandings gerados ou importados da pasta `{BLUEPRINTS / 'brandings'}`")
+    branding_upload = st.file_uploader("Subir Branding JSON", type=["json"], key="branding_upload")
+    if branding_upload and st.button("Guardar Branding", type="secondary"):
+        try:
+            data = json.loads(branding_upload.getvalue().decode("utf-8"))
+            if not isinstance(data, dict):
+                raise ValueError("O JSON raiz deve ser um objecto.")
+            target = BLUEPRINTS / "brandings" / (Path(branding_upload.name).stem.replace(" ", "-") + ".json")
+            target.parent.mkdir(parents=True, exist_ok=True)
+            atomic_write(target, data)
+            record_notification("branding_completed", f"Branding guardado: {target.stem}", "O Branding importado foi guardado no storage local.", metadata={"name": target.stem}, dedupe_key=f"branding:{target}:{target.stat().st_mtime_ns}")
+            st.success(f"Branding guardado em {target}")
+            st.rerun()
+        except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
+            st.error(f"Branding JSON inválido: {exc}")
+    branding_files = list_branding_files()
+    st.write(f"{len(branding_files)} branding(s) encontrado(s)")
+    branding_search = st.text_input("Pesquisar brandings", key="branding_search")
+    if not branding_files:
+        st.info("Ainda não existem brandings na pasta local.")
+    for path in branding_files:
+        if branding_search and branding_search.lower() not in path.name.lower():
+            continue
+        try:
+            data = load_blueprint_file(path)
+            title = data.get("name") or data.get("identity", {}).get("channel_name") or path.stem
+            with st.expander(f"{title} — {path.name}"):
+                st.caption(f"Blueprint associado: {data.get('blueprint_id') or 'não associado'}")
+                st.json(data)
+        except Exception as exc:
+            with st.expander(f"Inválido — {path.stem}"):
+                st.error(str(exc))
+
+
+def render_thumbnail_blueprints():
+    st.title("Thumbnail Blueprints")
+    st.caption(f"Documentos de estilo visual por nicho · armazenamento em `{BLUEPRINTS / 'thumbnails'}`")
+    st.info("Crie uma regra visual reutilizável a partir das thumbnails públicas de um canal concorrente. O documento gerado é separado do Blueprint de roteiro e será aplicado automaticamente ao canal associado.")
+    with st.form("create_thumbnail_blueprint_from_link"):
+        source_url = st.text_input("Link do canal ou vídeo YouTube", placeholder="https://www.youtube.com/@canal ou https://youtu.be/video")
+        niche = st.text_input("Nicho (usado no nome do ficheiro)", placeholder="Ex.: Militar")
+        channel_name = st.text_input("Nome do canal concorrente (opcional)")
+        sample_limit = st.slider("Vídeos públicos para analisar", 3, 10, 10)
+        submitted = st.form_submit_button("Analisar e criar Thumbnail Blueprint", type="primary")
+    if submitted:
+        if not source_url.strip() or not niche.strip():
+            st.error("Informe o link do YouTube e o nicho antes de criar.")
+        else:
+            try:
+                public = fetch_channel_videos_public(source_url, limit=sample_limit)
+                if not public.ok and not public.data.get("videos"):
+                    raise ValueError(public.message)
+                document = generate_thumbnail_blueprint(read_json("settings.json", {}), source_url=source_url.strip(), niche=niche.strip(), channel_name=channel_name.strip(), videos=public.data.get("videos", []))
+                path = save_thumbnail_blueprint(document)
+                st.success(f"Thumbnail Blueprint criado: {path.name} · {len(document.get('sample_videos', []))} referência(s) analisada(s).")
+                st.rerun()
+            except (ValueError, OSError) as exc:
+                st.error(str(exc))
+    st.divider()
+    st.subheader("Thumbnail Blueprints existentes")
+    search = st.text_input("Pesquisar Thumbnail Blueprints", key="thumbnail_blueprint_search")
+    documents = list_thumbnail_blueprint_documents()
+    if not documents:
+        st.info("Ainda não existem Thumbnail Blueprints. Use um link público do YouTube para criar o primeiro.")
+    for path in documents:
+        if search and search.casefold() not in path.name.casefold():
+            continue
+        with st.container(border=True):
+            st.markdown(f"### {path.stem}")
+            st.caption(f"Ficheiro: `{path.name}`")
+            pair_options = blueprint_catalog()
+            pair_ids = [item[0] for item in pair_options]
+            pair_labels = {item[0]: item[1] for item in pair_options}
+            pair = st.selectbox("Blueprint de roteiro associado", pair_ids, format_func=lambda item: pair_labels.get(item, item or "Sem Blueprint padrão"), key=f"thumbnail_card_pair_{path.stem}")
+            if st.button("Guardar associação deste card", key=f"thumbnail_card_pair_save_{path.stem}"):
+                save_thumbnail_blueprint_pair(path.stem, pair)
+                st.success("Associação guardada; canais com esse Blueprint usarão esta thumbnail blueprint automaticamente.")
+            st.code(path.read_text(encoding="utf-8"), language="markdown")
+    st.divider()
+    st.subheader("Associar ao canal e ao Blueprint de roteiro")
+    channels = read_json("channels.json", [])
+    thumbnail_options = thumbnail_blueprint_catalog()
+    thumbnail_ids = [item[0] for item in thumbnail_options]
+    thumbnail_labels = {item[0]: item[1] for item in thumbnail_options}
+    blueprint_options = blueprint_catalog()
+    blueprint_ids = [item[0] for item in blueprint_options]
+    blueprint_labels = {item[0]: item[1] for item in blueprint_options}
+    for channel in channels:
+        channel_id = str(channel.get("id") or "")
+        if not channel_id:
+            continue
+        with st.container(border=True):
+            st.write(f"**{channel.get('name', 'Canal')}**")
+            cols = st.columns(3)
+            current_thumb = str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or "")
+            current_script = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "")
+            with cols[0]:
+                thumb = st.selectbox("Thumbnail Blueprint", thumbnail_ids, index=thumbnail_ids.index(current_thumb) if current_thumb in thumbnail_ids else 0, format_func=lambda item: thumbnail_labels.get(item, item), key=f"thumbnail_blueprint_channel_{channel_id}")
+            with cols[1]:
+                script = st.selectbox("Blueprint de roteiro associado", blueprint_ids, index=blueprint_ids.index(current_script) if current_script in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"), key=f"thumbnail_script_blueprint_channel_{channel_id}")
+            with cols[2]:
+                if st.button("Guardar par", key=f"thumbnail_blueprint_save_{channel_id}", use_container_width=True):
+                    update_channel(channel_id, {"thumbnail_blueprint_id": thumb, "default_thumbnail_blueprint_id": thumb, "blueprint_id": script, "default_blueprint_id": script})
+                    st.success("Par Blueprint de roteiro + Thumbnail Blueprint guardado.")
+                    st.rerun()
 def _tiktok_accounts_from_settings(settings: dict[str, Any]) -> list[dict[str, Any]]:
     raw_accounts = settings.get("tiktok_accounts")
     if not isinstance(raw_accounts, list) or not raw_accounts:
@@ -2034,6 +2124,7 @@ def render_channels():
                 render_channel_edit_form(channel, youtube_account_ids, youtube_account_labels, youtube_accounts_by_id)
             else:
                 summary = channel_blueprint_summary(channel)
+                render_channel_thumbnail_blueprint_panel(channel, compact=True)
                 channel_language = language_label(channel.get("language") or "pt")
                 block_cols = st.columns(4, gap="small")
                 with block_cols[0]:
@@ -2370,6 +2461,7 @@ def render_new_video(page_title: str = "Criação de Vídeos", prefix: str = "ne
                     selected = [selected_one["id"]]
                     # Intentionally sits between Canal and the generation settings, as requested.
                     render_channel_blueprint_panel(selected_one)
+                    render_channel_thumbnail_blueprint_panel(selected_one)
                     generation_settings = render_video_generation_settings(
                         prefix,
                         current_language=str(st.session_state.get("video_language") or ""),
@@ -4179,7 +4271,11 @@ def render_automation():
             with header_cols[3]:
                 schedule_time = st.text_input("Horário (HH:MM)", value=channel.get("automation_time", "00:00"), key=f"automation_time_{channel_id}")
             blueprint_ids, blueprint_labels, current_blueprint, voice_options, current_voice = channel_default_options(channel)
-            default_cols = st.columns([1.15, 1.15, 1.5, 1.7, 1.35], gap="small")
+            thumbnail_items = thumbnail_blueprint_catalog()
+            thumbnail_ids = [item[0] for item in thumbnail_items]
+            thumbnail_labels = {item[0]: item[1] for item in thumbnail_items}
+            current_thumbnail = str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or "")
+            default_cols = st.columns([1.0, 1.0, 1.35, 1.55, 1.55, 1.0], gap="small")
             with default_cols[0]:
                 st.markdown("**Idioma Padrão**")
                 st.caption(language_label(channel.get("language") or "pt"))
@@ -4203,6 +4299,14 @@ def render_automation():
                     key=f"automation_voice_{channel_id}",
                 )
             with default_cols[4]:
+                automation_thumbnail = st.selectbox(
+                    "Thumbnail Blueprint",
+                    thumbnail_ids,
+                    index=thumbnail_ids.index(current_thumbnail) if current_thumbnail in thumbnail_ids else 0,
+                    format_func=lambda item: thumbnail_labels.get(item, item or "Sem Thumbnail Blueprint"),
+                    key=f"automation_thumbnail_blueprint_{channel_id}",
+                )
+            with default_cols[5]:
                 if st.button("Guardar", key=f"automation_save_{channel_id}", use_container_width=True):
                     if not valid_hhmm(schedule_time):
                         st.error("Use o formato HH:MM, por exemplo 08:30.")
@@ -4212,6 +4316,7 @@ def render_automation():
                             "automation_time": schedule_time.strip(),
                         })
                         set_channel_defaults(channel_id, automation_blueprint, automation_voice)
+                        update_channel(channel_id, {"thumbnail_blueprint_id": automation_thumbnail, "default_thumbnail_blueprint_id": automation_thumbnail})
                         st.success("Agendamento guardado.")
                         st.rerun()
 
@@ -7067,6 +7172,8 @@ def main():
     channel_profile_items = [
         ("Canais YouTube", ":material/ondemand_video:", "Canais YouTube"),
         ("Blueprints Youtube", ":material/library_books:", "Blueprints Youtube"),
+        ("Thumbnail Blueprints", ":material/image:", "Thumbnail Blueprints"),
+        ("Brandings Youtube", ":material/brush:", "Brandings Youtube"),
         ("Contas TikTok", ":material/account_circle:", "Contas TikTok"),
         ("Prompt Masters", ":material/auto_awesome:", "Prompt Masters"),
         ("Facebook Pages", ":material/public:", "Facebook Pages"),
@@ -7148,7 +7255,7 @@ def main():
         "Niche Finder": "/niche-finder", "Niche Finder Kaggle": "/niche-finder/kaggle", "Niche Finder Apify": "/niche-finder/apify",
         "Pipeline Vídeos": "/pipeline-videos", "Criação de Vídeos": "/pipeline-videos/criacao", "Backlog Vídeos": "/pipeline-videos/backlog", "Roteiros": "/pipeline-videos/roteiros", "Thumbnails": "/pipeline-videos/thumbnails", "Upload": "/pipeline-videos/upload",
         "Pipeline Música": "/pipeline-musica", "Criação de Músicas": "/pipeline-musica/criacao", "Music Backlog": "/pipeline-musica/backlog", "Vozes Personalizadas": "/pipeline-musica/vozes-personalizadas", "Upload Música": "/pipeline-musica/upload",
-        "Canais/Perfis (Vídeos)": "/canais-perfis-videos", "Canais YouTube": "/canais-perfis-videos/canais-youtube", "Blueprints Youtube": "/canais-perfis-videos/blueprints-youtube", "Contas TikTok": "/canais-perfis-videos/contas-tiktok", "Prompt Masters": "/canais-perfis-videos/prompt-masters", "Facebook Pages": "/canais-perfis-videos/facebook-pages",
+        "Canais/Perfis (Vídeos)": "/canais-perfis-videos", "Canais YouTube": "/canais-perfis-videos/canais-youtube", "Blueprints Youtube": "/canais-perfis-videos/blueprints-youtube", "Thumbnail Blueprints": "/canais-perfis-videos/thumbnail-blueprints", "Brandings Youtube": "/canais-perfis-videos/brandings-youtube", "Contas TikTok": "/canais-perfis-videos/contas-tiktok", "Prompt Masters": "/canais-perfis-videos/prompt-masters", "Facebook Pages": "/canais-perfis-videos/facebook-pages",
         "AI Influencers": "/ai-influencers", "Personagens": "/ai-influencers/personagens", "Geração de Conteúdo IA": "/ai-influencers/geracao-conteudo", "Motion Control": "/ai-influencers/motion-control", "UGC Products": "/ai-influencers/ugc-products", "Redes Sociais": "/ai-influencers/redes-sociais",
         "Edição": "/edicao", "Limpador de Metadados": "/edicao/limpador-metadados", "Cortes": "/edicao/cortes", "Editor Python": "/edicao/editor-python", "Download Mídia": "/edicao/download-midia",
         "Growth": "/growth", "Analista Growth Youtube": "/growth/youtube", "Analista Growth Tiktok": "/growth/tiktok", "Analista Growth Instagram": "/growth/instagram", "Analista Facebook Pages": "/growth/facebook-pages", "Analista Bilibili": "/growth/bilibili",
@@ -7226,6 +7333,8 @@ def main():
         "Thumbnails": render_thumbnails,
         "Upload": render_upload,
         "Blueprints Youtube": render_blueprints,
+        "Thumbnail Blueprints": render_thumbnail_blueprints,
+        "Brandings Youtube": render_youtube_brandings,
         "Prompt Masters": render_tiktok_prompt_masters,
         "Canais YouTube": render_channels,
         "Contas TikTok": render_tiktok_accounts,

package/hermes_ui/automation_worker.py

@@ -182,6 +182,7 @@ def _creative_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         "thumbnail_status": "pending_prompt",
         "blueprint_id": str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or ""),
         "blueprint_name": str(blueprint.get("name") or "SEM BLUEPRINT CONFIGURADO"),
+        "thumbnail_blueprint_id": str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or ""),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
         "material_source": material_source,
         "generation_settings": {"video_keywords": editorial.get("keywords", []), "material_source": material_source},
@@ -228,6 +229,7 @@ def _pending_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         "language": language,
         "blueprint_id": str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or ""),
         "blueprint_name": str(blueprint.get("name") or "SEM BLUEPRINT CONFIGURADO"),
+        "thumbnail_blueprint_id": str(channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id") or ""),
         "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
         "material_source": material_source,
         "generation_settings": {"material_source": material_source},

package/hermes_ui/creative_generation.py

@@ -136,6 +136,7 @@ def channel_context(channel: dict[str, Any], blueprint: dict[str, Any] | None =
         "blueprint_id": str(blueprint.get("id") or channel.get("default_blueprint_id") or channel.get("blueprint_id") or ""),
         "blueprint_name": str(blueprint.get("name") or "SEM BLUEPRINT CONFIGURADO"),
         "blueprint_niche": str(blueprint.get("target_niche") or blueprint.get("niche") or metadata.get("target_niche") or metadata.get("niche") or ""),
+        "thumbnail_blueprint_rules": str(blueprint.get("thumbnail_blueprint_rules") or "").strip(),
         "default_voice": str(channel.get("default_voice") or channel.get("voice") or ""),
     }
 

package/hermes_ui/domain.py

@@ -45,6 +45,8 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "language": "Português",
         "blueprint_id": "",
         "default_blueprint_id": "",
+        "thumbnail_blueprint_id": "",
+        "default_thumbnail_blueprint_id": "",
         "style_wide": "pexels",
         "voice": "",
         "default_voice": "",
@@ -178,6 +180,7 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "generation_settings": payload.get("generation_settings", options.get("generation_settings", {})),
                 "blueprint_id": payload.get("blueprint_id") or channel.get("default_blueprint_id") or channel.get("blueprint_id", ""),
                 "blueprint_name": payload.get("blueprint_name", ""),
+                "thumbnail_blueprint_id": payload.get("thumbnail_blueprint_id") or channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id", ""),
                 "voice": payload.get("voice") or channel.get("default_voice") or channel.get("voice", ""),
                 "automation_on": bool(channel.get("automation_on", False)),
                 "automation_time": channel.get("automation_time", "00:00"),

package/hermes_ui/thumbnail_blueprints.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping
+
+from .provider_routing import route_llm_json
+from .storage import BLUEPRINTS, atomic_write, list_blueprint_files, load_blueprint_file
+
+PROMPT_MASTER = '''You are a forensic YouTube thumbnail analyst. Build a reusable Thumbnail Blueprint from the reference channel videos below.
+The output must be a practical, locked visual system, not a script blueprint. Infer recurring composition, framing, lighting, color, typography, overlay text, symbols, emotional triggers, mobile readability, aspect ratio, quality and negative constraints. Use the exact Markdown structure of the requested reference: STYLE LOCK, FRAMING & POSE, BACKGROUND & LIGHTING, GEOPOLITICAL SYMBOLS when relevant, VISUAL ATTENTION ELEMENT, TEXT STYLE, TEXT PSYCHOLOGY, COMPOSITION RULES, FORMAT & QUALITY, FINAL OBJECTIVE, FINAL INPUT FORMAT and FINAL SYSTEM INSTRUCTION. Write the document in English. Do not invent channel analytics. The document must instruct future thumbnail generation and include a concise, ready-to-use image prompt template.'''
+
+
+def _slug(value: Any) -> str:
+    text = re.sub(r"[^A-Za-z0-9]+", "_", str(value or "").strip()).strip("_")
+    return text or "General"
+
+
+def _record_name(niche: str) -> str:
+    return f"{_slug(niche)}_Thumbnail_Blueprint"
+
+
+def thumbnail_blueprint_catalog() -> list[tuple[str, str]]:
+    folder = BLUEPRINTS / "thumbnails"
+    folder.mkdir(parents=True, exist_ok=True)
+    result: list[tuple[str, str]] = [("", "Sem Thumbnail Blueprint padrão")]
+    for path in sorted(folder.glob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True):
+        result.append((path.stem, path.stem))
+    return result
+
+
+def resolve_thumbnail_blueprint(identifier: Any) -> dict[str, Any]:
+    wanted = str(identifier or "").strip()
+    if not wanted:
+        return {}
+    folder = BLUEPRINTS / "thumbnails"
+    for path in folder.glob("*.md"):
+        if path.stem == wanted or path.name == wanted:
+            return {"id": path.stem, "name": path.stem, "path": str(path), "content": path.read_text(encoding="utf-8")}
+    return {"id": wanted, "name": wanted}
+
+
+def thumbnail_blueprint_for_channel(channel: Mapping[str, Any]) -> dict[str, Any]:
+    direct = channel.get("default_thumbnail_blueprint_id") or channel.get("thumbnail_blueprint_id")
+    if direct:
+        return resolve_thumbnail_blueprint(direct)
+    script_id = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "").strip()
+    pairs = _pair_state()
+    return resolve_thumbnail_blueprint(pairs.get(script_id, ""))
+
+
+def _pair_state() -> dict[str, str]:
+    path = BLUEPRINTS / "thumbnail_blueprint_pairs.json"
+    try:
+        value = __import__("json").loads(path.read_text(encoding="utf-8"))
+        return {str(k): str(v) for k, v in value.items()} if isinstance(value, dict) else {}
+    except (OSError, ValueError, TypeError):
+        return {}
+
+
+def save_thumbnail_blueprint_pair(thumbnail_id: str, blueprint_id: str) -> None:
+    pairs = _pair_state()
+    if blueprint_id:
+        pairs[str(blueprint_id)] = str(thumbnail_id)
+    else:
+        for key, value in list(pairs.items()):
+            if value == thumbnail_id:
+                pairs.pop(key, None)
+    atomic_write(BLUEPRINTS / "thumbnail_blueprint_pairs.json", pairs)
+
+
+def generate_thumbnail_blueprint(
+    settings: Mapping[str, Any],
+    *,
+    source_url: str,
+    niche: str,
+    channel_name: str = "",
+    videos: list[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    clean_niche = str(niche or "General").strip() or "General"
+    samples = list(videos or [])[:10]
+    sample_text = "\n".join(
+        f"- Title: {item.get('title', '')}\n  URL: {item.get('url', '')}\n  Thumbnail URL: {item.get('thumbnail_url', '')}"
+        for item in samples
+    ) or "- No public sample videos were available; produce a clearly marked baseline system from the niche."
+    user_prompt = f"Niche: {clean_niche}\nChannel: {channel_name}\nSource: {source_url}\nReference videos:\n{sample_text}\nReturn JSON with one key content containing only the complete Markdown document."
+    try:
+        routed = route_llm_json(settings, PROMPT_MASTER, user_prompt)
+        content = str(routed.payload.get("content") or "").strip()
+    except Exception as exc:
+        raise ValueError(f"Não foi possível gerar o Thumbnail Blueprint no provider configurado: {exc}") from exc
+    if not content:
+        raise ValueError("O provider não devolveu um documento Thumbnail Blueprint válido.")
+    if not content.startswith("#"):
+        content = f"# {_record_name(clean_niche)}\n\n" + content
+    return {
+        "id": _record_name(clean_niche),
+        "name": _record_name(clean_niche),
+        "niche": clean_niche,
+        "channel_name": channel_name,
+        "source_url": source_url,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "version": 1,
+        "sample_videos": samples,
+        "content": content.rstrip() + "\n",
+    }
+
+
+def save_thumbnail_blueprint(document: Mapping[str, Any]) -> Path:
+    name = _record_name(str(document.get("niche") or document.get("name") or "General").replace("_Thumbnail_Blueprint", ""))
+    folder = BLUEPRINTS / "thumbnails"
+    folder.mkdir(parents=True, exist_ok=True)
+    target = folder / f"{name}.md"
+    content = str(document.get("content") or "").strip()
+    if not content:
+        raise ValueError("O documento Thumbnail Blueprint não pode ficar vazio.")
+    front = ["---", f"type: thumbnail_blueprint", f"id: {name}", f"name: {name}", f"niche: {document.get('niche', '')}", f"source_url: {document.get('source_url', '')}", f"created_at: {document.get('created_at', '')}", "---", ""]
+    target.write_text("\n".join(front) + content + "\n", encoding="utf-8")
+    return target
+
+
+def list_thumbnail_blueprint_documents() -> list[Path]:
+    folder = BLUEPRINTS / "thumbnails"
+    folder.mkdir(parents=True, exist_ok=True)
+    return sorted(folder.glob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True)

package/package.json

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