@danhachuel/thunderbolt 0.4.16 → 0.4.17

package/hermes_ui/automation_worker.py

@@ -10,6 +10,7 @@ from typing import Any
 from . import storage
 from .creative_generation import generate_title_and_keywords, generate_topic_for_channel
 from .domain import create_batch, create_tasks_for_batch
+from .languages import language_code
 from .material_sources import selected_material_source
 from .notifications import record_notification
 from integrations.session_info_health import check_all_accounts_session_info_health, emit_session_info_health_alerts
@@ -124,6 +125,15 @@ def _valid_schedule(value: Any) -> bool:
     return 0 <= hour <= 23 and 0 <= minute <= 59
 
 
+def _scheduled_time(current: datetime, value: Any) -> datetime | None:
+    """Return today's scheduled local time, allowing a late worker tick to catch up."""
+    text = str(value or "").strip()
+    if not _valid_schedule(text):
+        return None
+    hour, minute = (int(part) for part in text.split(":"))
+    return current.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+
 def _daily_quantity(channel: dict[str, Any]) -> int:
     try:
         return max(1, min(100, int(channel.get("daily_limit", 1))))
@@ -198,14 +208,42 @@ def _tasks_for_batch(batch_id: str) -> list[dict[str, Any]]:
     return [task for task in tasks if isinstance(task, dict) and task.get("batch_id") == batch_id]
 
 
+def _pending_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    """Build the lightweight scheduled payload; creative work runs in the pipeline."""
+    settings = storage.read_json("settings.json", {})
+    blueprint = _blueprint_for_channel(channel)
+    style_wide = str(channel.get("style_wide") or "pexels").strip().casefold()
+    material_source = selected_material_source(settings) if style_wide in {"pexels", "pexels/pixabay", "stock"} else ""
+    language = language_code(channel.get("language") or "pt")
+    payload = {
+        "topic": "",
+        "topic_source": "llm_pending",
+        "title": "",
+        "title_candidates": [],
+        "thumbnail_variant": {},
+        "thumbnail_variants": [],
+        "thumbnail_prompt": "",
+        "thumbnail_text": "",
+        "thumbnail_status": "pending_prompt",
+        "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"),
+        "voice": str(channel.get("default_voice") or channel.get("voice") or ""),
+        "material_source": material_source,
+        "generation_settings": {"material_source": material_source},
+        "ai_generation": {},
+    }
+    return "", payload
+
+
 def _create_channel_batch(channel: dict[str, Any], when: datetime) -> dict[str, Any]:
     channel_id = str(channel["id"])
     date_key = when.date().isoformat()
     style_wide = str(channel.get("style_wide") or "pexels")
     music_mode = style_wide == "music"
-    topic, payload = _creative_payload(channel)
+    topic, payload = _pending_payload(channel)
     options = {
-        "language": channel.get("language") or "Português",
+        "language": payload.get("language") or channel.get("language") or "pt",
         "format": "wide",
         "style_wide": style_wide,
         "style_ia": channel.get("style_ia") or "",
@@ -214,7 +252,7 @@ def _create_channel_batch(channel: dict[str, Any], when: datetime) -> dict[str,
         "background_mode": "none" if music_mode else ("ai" if style_wide == "full_ia" else "stock"),
         "music_path": channel.get("music_path") or "",
         "music_source": channel.get("music_source") or "",
-        "topic_source": "llm",
+        "topic_source": payload.get("topic_source") or "llm_pending",
         "channel_payloads": {channel_id: payload},
         "automation_worker": True,
         "automation_date": date_key,
@@ -254,7 +292,8 @@ def run_once(when: datetime | None = None) -> dict[str, Any]:
             channel_id = str(channel.get("id") or "")
             if not channel_id or not bool(channel.get("active", True)) or not bool(channel.get("automation_on", False)):
                 continue
-            if not _valid_schedule(channel.get("automation_time")) or str(channel.get("automation_time")).strip() != current_minute:
+            scheduled_at = _scheduled_time(current, channel.get("automation_time"))
+            if scheduled_at is None or current < scheduled_at:
                 continue
             existing = _batch_for_day(channel_id, day)
             if existing:
@@ -263,12 +302,14 @@ def run_once(when: datetime | None = None) -> dict[str, Any]:
                     existing_tasks = create_tasks_for_batch(existing)
                 skipped.append(channel_id)
                 continue
-            created.append(_create_channel_batch(channel, current))
+            created.append(_create_channel_batch(channel, scheduled_at))
         for item in created:
             batch = item["batch"]
+            scheduled_at_value = str((batch.get("options") or {}).get("automation_scheduled_at") or "")
+            scheduled_time = scheduled_at_value[11:16] if len(scheduled_at_value) >= 16 else current_minute
             status["last_runs"][item["channel_id"]] = {
                 "date": day,
-                "time": current_minute,
+                "time": scheduled_time,
                 "batch_id": batch["id"],
                 "task_ids": [task["id"] for task in item["tasks"]],
             }
@@ -276,7 +317,7 @@ def run_once(when: datetime | None = None) -> dict[str, Any]:
                 "automation_completed",
                 "Automação concluída",
                 f"O lote agendado do canal {item['channel_id']} foi criado com sucesso.",
-                metadata={"channel_id": item["channel_id"], "batch_id": batch["id"], "time": current_minute},
+                metadata={"channel_id": item["channel_id"], "batch_id": batch["id"], "time": scheduled_time},
                 dedupe_key=f"automation:{batch['id']}",
             )
         _write_status(status)

package/hermes_ui/creative_generation.py

@@ -8,6 +8,7 @@ import requests
 from pathlib import Path
 from typing import Any
 
+from .languages import LANGUAGE_BY_CODE, language_code
 from .llm_providers import active_llm_card, provider_definition
 from .provider_routing import ProviderRoutingError, route_llm_json
 
@@ -30,6 +31,23 @@ class CreativeGenerationError(RuntimeError):
     """Raised when a configured LLM cannot produce a valid creative package."""
 
 
+_TARGET_LANGUAGE_NAMES = {
+    code: str(item.get("ui_name") or item.get("name") or code)
+    for code, item in LANGUAGE_BY_CODE.items()
+}
+
+
+def target_language(value: Any, default: str = "pt") -> tuple[str, str]:
+    """Return a canonical video-language code and an unambiguous prompt label."""
+    code = language_code(value, default=default)
+    return code, _TARGET_LANGUAGE_NAMES.get(code, code)
+
+
+def _language_instruction(value: Any, default: str = "pt") -> str:
+    code, label = target_language(value, default=default)
+    return f"{label} ({code})"
+
+
 def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
     card = active_llm_card(settings)
     provider = str(card.get("provider") or "openai").strip().lower()
@@ -112,7 +130,8 @@ def channel_context(channel: dict[str, Any], blueprint: dict[str, Any] | None =
         "channel_name": str(channel.get("name") or "Canal sem nome"),
         "handle": str(channel.get("handle") or ""),
         "description": str(channel.get("description") or ""),
-        "language": str(channel.get("language") or "Português"),
+        "language": language_code(channel.get("language") or "pt"),
+        "language_name": _TARGET_LANGUAGE_NAMES.get(language_code(channel.get("language") or "pt"), "Portuguese"),
         "style_wide": str(channel.get("style_wide") or "pexels"),
         "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"),
@@ -136,9 +155,12 @@ def generate_video_description(
     if not topic and not title:
         raise CreativeGenerationError("É necessário um tópico ou título antes de gerar a descrição do vídeo.")
     context = channel_context(channel)
+    requested_language = language or channel.get("language") or context["language"]
+    language_instruction = _language_instruction(requested_language)
     normalized_tags = [str(item).strip() for item in (tags or []) if str(item).strip()][:15]
     system = (
         "És um editor de metadados de YouTube. Cria uma descrição útil, clara e envolvente para o vídeo, "
+        f"e escreve todos os campos textuais de saída em {language_instruction}. "
         "sem alegações não verificadas, sem clickbait falso e sem mencionar que foi gerada por IA. "
         "Usa dois parágrafos curtos, inclui um convite natural para subscrever quando apropriado e devolve "
         "apenas JSON válido com a chave description."
@@ -146,7 +168,8 @@ def generate_video_description(
     user = json.dumps(
         {
             "channel": context,
-            "language": language or context["language"],
+            "language": target_language(requested_language)[0],
+            "language_name": target_language(requested_language)[1],
             "topic": topic,
             "title": title or topic,
             "tags": normalized_tags,
@@ -168,8 +191,10 @@ def generate_topic_for_channel(
     user_context: str = "",
 ) -> dict[str, Any]:
     context = channel_context(channel, blueprint)
+    language_instruction = _language_instruction(channel.get("language") or context["language"])
     system = (
         "És o estratega editorial de um canal faceless. Gera um briefing específico para este canal. "
+        f"Todos os campos textuais devolvidos devem estar em {language_instruction}. "
         "Não inventes factos sobre o canal. Se o contexto já tiver um tópico, desenvolve-o sem trocar o nicho. "
         "Escreve de forma natural, sem introduções artificiais, frases de IA, clickbait enganoso ou CTA genérico. "
         "Responde apenas com JSON válido com as chaves topic, angle, hook, niche e rationale."
@@ -177,6 +202,7 @@ def generate_topic_for_channel(
     user = json.dumps(
         {
             "channel": context,
+            "output_language": language_instruction,
             "user_context": user_context.strip(),
             "reference_rules": reference_bundle(),
             "requirements": [
@@ -294,8 +320,11 @@ def generate_thumbnail_prompt(
     if not topic:
         raise CreativeGenerationError("É necessário um tópico para refazer o prompt da thumbnail.")
     context = channel_context(channel, blueprint)
+    requested_language = language or channel.get("language") or context["language"]
+    language_instruction = _language_instruction(requested_language)
     system = (
         "És um director de arte de thumbnails para YouTube. Refaz um prompt de imagem forte e específico "
+        f"O overlay_text e todo o texto editorial devem estar em {language_instruction}; o image_prompt pode permanecer em inglês. "
         "para o tópico fornecido, mantendo a intenção visual quando já existir um prompt. "
         "Separa rigorosamente a imagem sem texto do lettering: image_prompt nunca deve pedir texto renderizado, "
         "enquanto overlay_text é obrigatório, deve ser curto, legível e ter entre três e quatro palavras. "
@@ -305,7 +334,8 @@ def generate_thumbnail_prompt(
     user = json.dumps(
         {
             "channel": context,
-            "language": language or context["language"],
+            "language": target_language(requested_language)[0],
+            "language_name": target_language(requested_language)[1],
             "topic": topic,
             "current_prompt": str(current_prompt or "").strip(),
             "reference_rules": reference_bundle(),
@@ -350,8 +380,11 @@ def generate_title_and_keywords(
     if not topic.strip():
         raise CreativeGenerationError("É necessário um tópico ou briefing antes de gerar título e keywords.")
     context = channel_context(channel, blueprint)
+    requested_language = language or channel.get("language") or context["language"]
+    language_instruction = _language_instruction(requested_language)
     system = (
         "És um director editorial para YouTube. Cria apenas o pacote editorial do vídeo: títulos candidatos e keywords SEO. "
+        f"Todos os títulos, fórmulas e campos editoriais textuais devem estar em {language_instruction}; as keywords podem permanecer em inglês para SEO. "
         "Não cries prompts, conceitos ou variantes de thumbnail. Gera exactamente pelo menos 20 títulos candidatos, "
         "um título seleccionado e entre 8 e 15 keywords curtas. O título deve carregar keywords no início, ter curiosidade, "
         "especificidade e emoção, sem clickbait falso. Responde apenas com JSON válido nas chaves selected_title, "
@@ -360,7 +393,8 @@ def generate_title_and_keywords(
     user = json.dumps(
         {
             "channel": context,
-            "language": language or context["language"],
+            "language": target_language(requested_language)[0],
+            "language_name": target_language(requested_language)[1],
             "topic": topic.strip(),
             "reference_rules": reference_bundle(),
             "keywords_schema": ["lista de 8 a 15 keywords SEO curtas, sem hashtags"],
@@ -419,8 +453,11 @@ def generate_creative_package(
     if not topic.strip():
         raise CreativeGenerationError("É necessário um tópico ou briefing antes de gerar título e thumbnail.")
     context = channel_context(channel, blueprint)
+    requested_language = language or channel.get("language") or context["language"]
+    language_instruction = _language_instruction(requested_language)
     system = (
         "És director editorial e de thumbnails para YouTube. Cria um pacote coerente de título e thumbnail "
+        f"Todos os títulos e textos visíveis da thumbnail devem estar em {language_instruction}; o image_prompt pode permanecer em inglês. "
         "para o tópico fornecido. Gera exactamente pelo menos 20 títulos candidatos e entre 3 e 5 variantes de thumbnail. "
         "O título deve carregar keywords no início, ter curiosidade, especificidade e emoção, sem clickbait falso. "
         "A thumbnail deve ter no máximo três elementos, alto contraste, uma composição clara e lettering obrigatório de 3 a 4 palavras, "
@@ -430,7 +467,8 @@ def generate_creative_package(
     user = json.dumps(
         {
             "channel": context,
-            "language": language or context["language"],
+            "language": target_language(requested_language)[0],
+            "language_name": target_language(requested_language)[1],
             "topic": topic.strip(),
             "reference_rules": reference_bundle(),
             "keywords_schema": ["lista de 8 a 15 keywords SEO curtas, sem hashtags"],

package/hermes_ui/domain.py

@@ -130,13 +130,19 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
         payload = payload if isinstance(payload, dict) else {}
         for index in range(count):
             default_topic = str(batch.get("topic") or "").strip()
+            topic_source = str(payload.get("topic_source") or options.get("topic_source") or "manual")
+            payload_topic = str(payload.get("topic") or "").strip()
             if count == 1:
-                topic = str(payload.get("topic") or default_topic).strip()
+                topic = payload_topic or default_topic
+            elif payload_topic or default_topic:
+                topic = payload_topic or f"{default_topic} — variação {index + 1}"
             else:
-                topic = str(payload.get("topic") or f"{default_topic} — variação {index + 1}").strip()
-            if not topic:
+                topic = ""
+            topic = topic.strip()
+            pending_creative = not topic and topic_source in {"auto", "llm_pending"}
+            if not topic and not pending_creative:
                 topic = f"Vídeo para {channel.get('name', 'Canal')}"
-            title = str(payload.get("title") or topic).strip()
+            title = str(payload.get("title") or ("" if pending_creative else topic)).strip()
             artifacts = dict(payload.get("artifacts") or {})
             thumbnail_variants = payload.get("thumbnail_variants") if isinstance(payload.get("thumbnail_variants"), list) else []
             thumbnail_variant = payload.get("thumbnail_variant") if isinstance(payload.get("thumbnail_variant"), dict) else {}
@@ -150,7 +156,7 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
             thumbnail_status = str(payload.get("thumbnail_status") or ("generated" if thumbnail_path else "not_generated"))
             if thumbnail_path:
                 artifacts.setdefault("thumbnail", thumbnail_path)
-            initial_stage = "topic" if not topic and str(payload.get("topic_source") or options.get("topic_source") or "manual") in {"auto", "llm_pending"} else "script"
+            initial_stage = "topic" if pending_creative else "script"
             task = {
                 "id": make_id("video"),
                 "batch_id": batch["id"],
@@ -159,7 +165,7 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
                 "channel_name": channel.get("name", "Canal"),
                 "topic": topic,
                 "title": title,
-                "topic_source": str(payload.get("topic_source") or options.get("topic_source") or "manual"),
+                "topic_source": topic_source,
                 "language": payload.get("language", options.get("language", channel.get("language", "Português"))),
                 "format": payload.get("format", options.get("format", "wide")),
                 "style_wide": payload.get("style_wide", options.get("style_wide", channel.get("style_wide", "pexels"))),

package/hermes_ui/script_generation.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 from typing import Any
 
-from .creative_generation import CreativeGenerationError, _chat_json, channel_context
+from .creative_generation import CreativeGenerationError, _chat_json, channel_context, target_language
 
 
 DOCUMENT_TYPES = {
@@ -38,6 +38,8 @@ def generate_script_document(
         raise CreativeGenerationError("Escreva um tema ou briefing antes de gerar o documento.")
 
     channel_context_value = channel_context(channel or {}, blueprint or {})
+    requested_language = language or channel_context_value["language"]
+    language_code, language_name = target_language(requested_language)
     blueprint_payload = blueprint or {}
     generation_settings_payload = generation_settings or {}
     if normalized_type == "video_script":
@@ -47,6 +49,7 @@ def generate_script_document(
         }
         system = (
             "És um roteirista editorial de vídeos faceless. Cria um roteiro original, natural e executável, "
+            f"escrevendo título, resumo e conteúdo integralmente em {language_name} ({language_code}). "
             "alinhado exclusivamente ao nicho e às regras do Blueprint fornecido. Não inventes factos sensíveis, "
             "não uses introduções genéricas, não escrevas comentários sobre IA e não incluas um CTA vazio. "
             "Responde apenas com JSON válido nas chaves title, summary e content."
@@ -58,6 +61,7 @@ def generate_script_document(
         }
         system = (
             "És um compositor de letras originais. Cria uma letra cantável, coerente com o tema, idioma, "
+            f"escrevendo título, resumo e conteúdo integralmente em {language_name} ({language_code}). "
             "Blueprint e direcção musical fornecidos. Não copies letras existentes, não cites artistas sem pedido "
             "e não acrescentes explicações dentro da letra. Responde apenas com JSON válido nas chaves title, summary e content."
         )
@@ -67,7 +71,8 @@ def generate_script_document(
             "document_type": normalized_type,
             "requested_title": title.strip(),
             "brief": brief.strip(),
-            "language": language.strip(),
+            "language": language_code,
+            "language_name": language_name,
             "channel": channel_context_value,
             "blueprint": blueprint_payload,
             "structure_notes": structure_notes.strip(),
@@ -85,7 +90,7 @@ def generate_script_document(
         "title": str(result.get("title") or title or brief).strip(),
         "summary": str(result.get("summary") or "").strip(),
         "content": content,
-        "language": language.strip(),
+        "language": language_code,
         "blueprint_id": str(blueprint_payload.get("id") or ""),
         "blueprint_name": str(blueprint_payload.get("name") or "SEM BLUEPRINT CONFIGURADO"),
         "channel_id": str((channel or {}).get("id") or ""),

package/package.json

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