@danhachuel/thunderbolt 0.3.97 → 0.3.99

package/app/influencers_ui.py

@@ -6,6 +6,7 @@ import base64
 import hashlib
 import io
 import json
+import mimetypes
 from pathlib import Path
 from typing import Any, Mapping
 
@@ -294,24 +295,38 @@ def _render_content_history(repository: Any, influencer_id: str = "") -> None:
     if not records:
         return
     st.subheader("Conteúdos gerados")
-    rows = []
     for item in records:
-        rows.append({
-            "Tipo": str(item.get("content_type") or "").capitalize(),
-            "Estado": CONTENT_STATES.get(str(item.get("state") or ""), str(item.get("state") or "—")),
-            "Provider": f"{item.get('provider') or '—'} · {item.get('model') or '—'}",
-            "Plataforma": item.get("platform") or "—",
-            "Artefacto": item.get("artifact_path") or item.get("error") or "—",
-            "Criado": item.get("created_at") or "—",
-        })
-    st.dataframe(rows, use_container_width=True, hide_index=True)
-    latest = records[0]
-    artifact = Path(str(latest.get("artifact_path") or ""))
-    if artifact.is_file() and latest.get("state") == "completed":
-        if latest.get("content_type") == "image":
-            st.image(str(artifact), caption="Última imagem gerada", use_container_width=True)
-        elif latest.get("content_type") == "video":
-            st.video(str(artifact))
+        content_id = str(item.get("id") or "content")
+        content_type = str(item.get("content_type") or "").strip().lower()
+        artifact = Path(str(item.get("artifact_path") or ""))
+        state = str(item.get("state") or "")
+        type_label = "Imagem" if content_type == "image" else "Vídeo" if content_type == "video" else "Conteúdo"
+        with st.container(border=True):
+            preview_col, detail_col = st.columns([1.25, 2.75])
+            with preview_col:
+                if artifact.is_file() and content_type == "image":
+                    st.image(str(artifact), caption=f"{type_label} gerada", use_container_width=True)
+                elif artifact.is_file() and content_type == "video":
+                    st.video(str(artifact))
+                else:
+                    st.caption("Artefacto indisponível")
+            with detail_col:
+                st.write(f"**{type_label} · {CONTENT_STATES.get(state, state or '—')}**")
+                st.caption(f"Provider: {item.get('provider') or '—'} · {item.get('model') or '—'}")
+                st.caption(f"Plataforma: {item.get('platform') or '—'} · Criado: {item.get('created_at') or '—'}")
+                if item.get("error"):
+                    st.error(str(item.get("error") or "")[:700])
+                if artifact.is_file() and state == "completed" and content_type in {"image", "video"}:
+                    fallback_mime = "image/png" if content_type == "image" else "video/mp4"
+                    mime = mimetypes.guess_type(artifact.name)[0] or fallback_mime
+                    st.download_button(
+                        f"Descarregar {type_label.casefold()}",
+                        data=artifact.read_bytes(),
+                        file_name=artifact.name,
+                        mime=mime,
+                        key=f"influencer_content_download_{content_type}_{content_id}",
+                        use_container_width=True,
+                    )
 
 
 def _store_uploaded_file(uploaded: Any, folder: str) -> Path:

package/app/main.py

@@ -43,6 +43,7 @@ from hermes_ui.material_sources import apply_material_source_cards_to_settings,
 from hermes_ui.llm_providers import LLM_CARDS_KEY, LLM_PROVIDER_CATALOG, apply_llm_cards_to_settings, ensure_llm_provider_cards, new_llm_card, normalize_llm_card, provider_definition, test_llm_provider_card, stamp_test_result
 from hermes_ui.media_providers import FULL_IA_VIDEO_PROVIDER_CODES, MEDIA_CARDS_KEY, MEDIA_IMAGE_ACTIVE_CARD_KEY, MEDIA_VIDEO_ACTIVE_CARD_KEY, apply_media_provider_cards_to_settings, ensure_media_provider_cards, media_cards_for_pool, media_provider_catalog, media_provider_definition, new_media_card, normalize_media_card
 from hermes_ui.music import create_music_task, list_music_files, list_music_tasks, materialize_suno_audio, request_suno_generation, run_music_task, store_music_file, store_voiceover_file, transition_music_task
+from hermes_ui.music_generation import MUSIC_GENRES, MUSIC_VOCAL_OPTIONS, generate_music_fields
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
 from hermes_ui.influencers import BACKEND_OPTIONS, DOCUMENT_EXTENSIONS, IMAGE_EXTENSIONS, backend_name, backend_status, get_repository, test_backend
@@ -2651,20 +2652,75 @@ def render_music_creation():
     st.title("Criação de Músicas")
     st.caption("Crie apenas áudio. Os pedidos desta página não criam vídeo, não usam o MoneyPrinterTurbo e não entram no Backlog Vídeos.")
     settings = read_json("settings.json", {})
-    with st.form("create_music_task_form"):
-        provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria"], key="music_task_provider")
-        title = st.text_input("Título da música", key="music_task_title")
-        prompt = st.text_area("Prompt musical", placeholder="Instrumental cinematográfico, calmo, sem voz...", key="music_task_prompt", height=150)
-        lyria_model = ""
-        if provider_label == "Google Lyria":
-            models = ["lyria-3-clip-preview", "lyria-3-pro-preview"]
-            configured = str(settings.get("lyria_model") or models[0])
-            lyria_model = st.selectbox("Modelo Lyria", models, index=models.index(configured) if configured in models else 0, key="music_task_lyria_model")
-        submitted = st.form_submit_button("Adicionar ao Music Backlog", type="primary", use_container_width=True)
-    if submitted:
+    generated_fields = st.session_state.pop("music_task_generated_fields", None)
+    if isinstance(generated_fields, dict):
+        for state_key, generated_key in (
+            ("music_task_title", "title"),
+            ("music_task_language", "language"),
+            ("music_task_genre", "genre"),
+            ("music_task_vocal", "vocal"),
+            ("music_task_references", "references"),
+            ("music_task_prompt", "prompt"),
+        ):
+            st.session_state[state_key] = str(generated_fields.get(generated_key) or "")
+    provider_label = st.selectbox("Provider de geração musical", ["Suno AI", "Google Lyria"], key="music_task_provider")
+    theme = st.text_input("Tema / assunto principal", key="music_task_theme", placeholder="Ex.: uma viagem nocturna pela costa portuguesa")
+    title = st.text_input("Título da música", key="music_task_title")
+    language = st.selectbox(
+        "Idioma da letra/música",
+        list(LANGUAGE_CODES),
+        index=list(LANGUAGE_CODES).index(str(st.session_state.get("music_task_language") or "pt")) if str(st.session_state.get("music_task_language") or "pt") in LANGUAGE_CODES else list(LANGUAGE_CODES).index("pt"),
+        format_func=language_label,
+        key="music_task_language",
+    )
+    genre = st.selectbox("Género musical", list(MUSIC_GENRES), key="music_task_genre")
+    vocal = st.selectbox("Vocal", list(MUSIC_VOCAL_OPTIONS), key="music_task_vocal")
+    references = st.text_area(
+        "Referências culturais, paisagens, clima ou artistas similares (opcional)",
+        key="music_task_references",
+        placeholder="Ex.: pôr do sol mediterrânico, estrada molhada, nostalgia suave e arranjos acústicos contemporâneos",
+        height=90,
+    )
+    if st.button("Gerar campos musicais com IA", key="music_task_generate_fields", use_container_width=True, icon=":material/auto_awesome:"):
+        try:
+            with st.spinner("A criar título, letra e prompt musical originais…"):
+                generated = generate_music_fields(
+                    settings,
+                    theme=theme,
+                    language=language,
+                    genre=genre,
+                    vocal=vocal,
+                    references=references,
+                )
+            st.session_state["music_task_generated_fields"] = generated
+            st.rerun()
+        except CreativeGenerationError as exc:
+            st.error(str(exc))
+    prompt = st.text_area(
+        "Prompt musical",
+        placeholder="Use Gerar campos musicais com IA para criar letra e estilo completos, ou escreva um prompt próprio.",
+        key="music_task_prompt",
+        height=300,
+    )
+    lyria_model = ""
+    if provider_label == "Google Lyria":
+        models = ["lyria-3-clip-preview", "lyria-3-pro-preview"]
+        configured = str(settings.get("lyria_model") or models[0])
+        lyria_model = st.selectbox("Modelo Lyria", models, index=models.index(configured) if configured in models else 0, key="music_task_lyria_model")
+    if st.button("Gerar Música", key="music_task_submit", type="primary", use_container_width=True, icon=":material/music_note:"):
         try:
-            task = create_music_task(provider_label, prompt, title, lyria_model)
-            st.success(f"Música adicionada ao Music Backlog: {task['title']}")
+            task = create_music_task(
+                provider_label,
+                prompt,
+                title,
+                lyria_model,
+                language=language,
+                genre=genre,
+                vocal=vocal,
+                references=references,
+                theme=theme,
+            )
+            st.success(f"Música criada no Music Backlog: {task['title']}")
             st.rerun()
         except ValueError as exc:
             st.error(str(exc))
@@ -3788,7 +3844,7 @@ def render_music_backlog() -> None:
                     music_file = Path(music_path)
                     st.success("Música pronta; pode continuar para o destino configurado.")
                     st.download_button(
-                        "Descarregar música pronta",
+                        "Descarregar música",
                         data=music_file.read_bytes(),
                         file_name=music_file.name,
                         mime="audio/mpeg",
@@ -3865,6 +3921,14 @@ def render_thumbnails():
                 image_path = record.get("image_path")
                 if image_path and image_path.is_file():
                     st.image(str(image_path), use_container_width=True)
+                    st.download_button(
+                        "Descarregar thumbnail",
+                        data=image_path.read_bytes(),
+                        file_name=image_path.name,
+                        mime="image/jpeg" if image_path.suffix.lower() in {".jpg", ".jpeg"} else "image/png",
+                        key=f"thumbnail_download_{task_id}_{record['variant_index']}",
+                        use_container_width=True,
+                    )
                 else:
                     st.markdown("### Sem imagem")
                     st.caption("Imagem ainda não gerada")

package/hermes_ui/music.py

@@ -97,7 +97,14 @@ def materialize_suno_audio(data: dict[str, Any], title: str = "suno-generated.mp
     return store_music_file(title, response.content)
 
 
-def request_suno_generation(settings: dict[str, Any], prompt: str, title: str = "", duration_seconds: int = 120) -> dict[str, Any]:
+def request_suno_generation(
+    settings: dict[str, Any],
+    prompt: str,
+    title: str = "",
+    duration_seconds: int = 120,
+    *,
+    make_instrumental: bool = True,
+) -> dict[str, Any]:
     """Request music from a configured Suno-compatible endpoint.
 
     Suno-compatible deployments expose different endpoint paths; the UI therefore
@@ -109,7 +116,12 @@ def request_suno_generation(settings: dict[str, Any], prompt: str, title: str =
     if not api_key or not base_url:
         return {"ok": False, "message": "Configure Suno API Key e Suno API Base URL em Configurações antes de solicitar uma música.", "data": {}}
     url = endpoint if endpoint.startswith("http") else f"{base_url}/{endpoint.lstrip('/')}"
-    payload = {"prompt": prompt.strip(), "title": title.strip(), "duration": max(120, int(duration_seconds)), "make_instrumental": True}
+    payload = {
+        "prompt": prompt.strip(),
+        "title": title.strip(),
+        "duration": max(120, int(duration_seconds)),
+        "make_instrumental": bool(make_instrumental),
+    }
     try:
         response = requests.post(url, json=payload, headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, timeout=30)
         if response.status_code >= 400:
@@ -132,7 +144,18 @@ def _save_music_tasks(tasks: list[dict[str, Any]]) -> None:
     storage.write_json("music_tasks.json", tasks)
 
 
-def create_music_task(provider: str, prompt: str, title: str, model: str = "") -> dict[str, Any]:
+def create_music_task(
+    provider: str,
+    prompt: str,
+    title: str,
+    model: str = "",
+    *,
+    language: str = "",
+    genre: str = "",
+    vocal: str = "",
+    references: str = "",
+    theme: str = "",
+) -> dict[str, Any]:
     """Enqueue one audio-only generation; no video task or video worker is used."""
     cleaned_prompt = str(prompt or "").strip()
     if not cleaned_prompt:
@@ -145,6 +168,12 @@ def create_music_task(provider: str, prompt: str, title: str, model: str = "") -
         "model": str(model or "").strip(),
         "title": str(title or "Música sem título").strip() or "Música sem título",
         "prompt": cleaned_prompt,
+        "language": str(language or "").strip(),
+        "genre": str(genre or "").strip(),
+        "vocal": str(vocal or "").strip(),
+        "references": str(references or "").strip(),
+        "theme": str(theme or "").strip(),
+        "duration_seconds": 120,
         "state": "to_do",
         "stage": "music_generation",
         "progress": 0,
@@ -240,7 +269,13 @@ def run_music_task(task_id: str, settings: dict[str, Any]) -> dict[str, Any] | N
         result = request_lyria_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""), str(task.get("model") or ""))
         audio_path = str((result.get("data") or {}).get("audio_path") or "")
     else:
-        result = request_suno_generation(settings, str(task.get("prompt") or ""), str(task.get("title") or ""))
+        result = request_suno_generation(
+            settings,
+            str(task.get("prompt") or ""),
+            str(task.get("title") or ""),
+            int(task.get("duration_seconds") or 120),
+            make_instrumental=not bool(str(task.get("vocal") or "").strip()),
+        )
         try:
             output = materialize_suno_audio(result.get("data") or {}, str(task.get("title") or "suno-generated.mp3")) if result.get("ok") else None
             audio_path = str(output or "")

package/hermes_ui/music_generation.py

@@ -0,0 +1,88 @@
+"""Structured, original music briefs generated through the configured LLM pool."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .creative_generation import CreativeGenerationError, _chat_json
+from .languages import language_code
+
+
+MUSIC_GENRES = (
+    "Pop", "Rock", "Hip Hop", "EDM (Eletrônica)", "Techno", "Country", "Folk", "Indie", "K-pop", "Jazz",
+    "Reggae", "Classical", "Metal", "Punk", "Afrobeat (Nigéria)", "Ambient (Reino Unido)", "Anime (Japão)",
+    "Arabic Pop / Khaleeji (Mundo Árabe)", "Austropop (Áustria)", "Ballad (Internacional)", "Banda (México)",
+    "Blues (EUA)", "Bollywood / Indian (Índia)", "City Pop (Japão)", "Corridos Tumbados (México)", "C-pop (China)",
+    "Cumbia (Colômbia)", "Dangdut (Indonésia)", "Dansband (Suécia)", "Deutschrap (Alemanha)",
+    "Disco Polo (Polônia)", "Drum & Bass (Reino Unido)", "Entechno (Grécia)", "Fado (Portugal)",
+    "Flamenco (Espanha)", "Forró (Brasil)", "Funk (Brasil)", "Fusion (Internacional)", "Gamolan (Indonésia)",
+    "Gospel (EUA)", "Grime (Reino Unido)", "Hardstyle (Países Baixos)", "J-Pop (Japão)", "J-Rock (Japão)",
+    "K-Hip Hop (Coreia do Sul)", "Kizomba (Angola)", "Klapa (Croácia)", "Klezmer (Judeu / Europa Oriental)",
+    "Laïko (Grécia)", "Latin (América Latina)", "Mandopop (China / Taiwan)", "Māori (Nova Zelândia)", "MPB (Brasil)",
+    "Mundart (Dialect Pop) (Suíça)", "Pasifika (Pacífico)", "Pimba (Portugal)", "Pop Sueco (Suécia)", "R&B (EUA)",
+    "Rap Francês (França)", "Reggaeton (Porto Rico)", "Regional Mexicano (México)", "Samba / Pagode (Brasil)",
+    "Schlager (Alemanha)", "Sertanejo (Brasil)", "Trot (Coreia do Sul)", "Urbano / Trap (América Latina)",
+    "Variété (França)", "Vocaloid (Japão)",
+)
+MUSIC_VOCAL_OPTIONS = ("Masculino", "Feminina", "Coral")
+
+
+def generate_music_fields(
+    settings: dict[str, Any],
+    *,
+    theme: str,
+    language: str,
+    genre: str,
+    vocal: str,
+    references: str = "",
+) -> dict[str, str]:
+    """Generate original, ready-to-use music fields through the active LLM pool."""
+    cleaned_theme = str(theme or "").strip()
+    if not cleaned_theme:
+        raise CreativeGenerationError("Escreva o tema ou assunto principal antes de gerar os campos musicais com IA.")
+    selected_genre = str(genre or "").strip()
+    selected_vocal = str(vocal or "").strip()
+    selected_language = language_code(language)
+    system = (
+        "És um compositor e produtor musical. Cria uma canção inteiramente original, sem reproduzir letras, melodias, "
+        "frases distintivas ou a identidade de artistas existentes. As referências fornecidas servem apenas para atributos "
+        "de alto nível, como instrumentação, clima, contexto cultural e energia. Responde apenas com JSON válido contendo "
+        "as chaves title, language, genre, vocal, cultural_references e music_prompt. "
+        "music_prompt deve ser Markdown legível, pronto para uma ferramenta de geração musical, com exactamente estas secções: "
+        "# 1. Nome da Música, # 2. Idioma da Música, # 3. Letra / Lyrics, # 4. Estilo / Style Prompt. "
+        "A letra deve ser original, incluir [Intro], [Verse 1], [Pre-Chorus], [Chorus], [Verse 2], [Bridge], "
+        "[Instrumental Solo], [Final Chorus] e [Outro], ter uma estrutura que vise pelo menos dois minutos, e o estilo deve "
+        "informar subgénero, vocal, instrumentação, BPM, clima, produção e estrutura."
+    )
+    user = json.dumps(
+        {
+            "theme": cleaned_theme,
+            "selected_language_code": selected_language,
+            "selected_genre": selected_genre,
+            "selected_vocal": selected_vocal,
+            "cultural_landscape_weather_or_artist_references": str(references or "").strip(),
+            "available_genres": list(MUSIC_GENRES),
+            "available_vocals": list(MUSIC_VOCAL_OPTIONS),
+            "requirements": {
+                "minimum_target_duration_seconds": 120,
+                "preserve_selected_language_genre_and_vocal_when_present": True,
+                "output_original_content_only": True,
+            },
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    music_prompt = str(result.get("music_prompt") or "").strip()
+    if not music_prompt:
+        raise CreativeGenerationError("O provider LLM não devolveu um prompt musical válido.")
+    generated_genre = str(result.get("genre") or selected_genre).strip()
+    generated_vocal = str(result.get("vocal") or selected_vocal).strip()
+    return {
+        "title": str(result.get("title") or cleaned_theme).strip()[:180],
+        "language": language_code(result.get("language"), default=selected_language),
+        "genre": generated_genre if generated_genre in MUSIC_GENRES else selected_genre,
+        "vocal": generated_vocal if generated_vocal in MUSIC_VOCAL_OPTIONS else selected_vocal,
+        "references": str(result.get("cultural_references") or references or "").strip()[:800],
+        "prompt": music_prompt[:16000],
+    }

package/package.json

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