@danhachuel/thunderbolt 0.2.49 → 0.2.50

package/hermes_ui/creative_generation.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import json
+import re
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+ROOT = Path(__file__).resolve().parents[1]
+REFERENCES_DIR = ROOT / "seed" / "references"
+
+REFERENCE_FILES = {
+    "title_formulas": "title-formulas.md",
+    "viral_titles": "viral-titles.md",
+    "thumbnail_checklist": "thumbnail-checklist.md",
+    "viral_thumbnails": "viral-thumbnails.md",
+    "trend_intelligence": "trend-intelligence.md",
+    "humanize": "humanize-integration.md",
+    "ai_tells": "ai-tells.md",
+}
+
+
+class CreativeGenerationError(RuntimeError):
+    """Raised when a configured LLM cannot produce a valid creative package."""
+
+
+def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
+    provider = str(settings.get("llm_provider") or "openai").strip().lower()
+    key = str(settings.get(f"{provider}_api_key") or "").strip()
+    base_url = str(settings.get(f"{provider}_base_url") or "").strip()
+    model = str(settings.get(f"{provider}_model_name") or "").strip()
+    if provider == "openai":
+        base_url = base_url or "https://api.openai.com/v1"
+    elif provider == "ollama":
+        base_url = base_url or "http://127.0.0.1:11434/v1"
+    if not base_url:
+        raise CreativeGenerationError(
+            f"O provider LLM '{provider}' não tem Base URL configurada em Configurações Técnicas > API Keys."
+        )
+    if not model:
+        raise CreativeGenerationError(
+            f"O provider LLM '{provider}' não tem modelo configurado em Configurações Técnicas > API Keys."
+        )
+    if provider not in {"ollama", "litellm"} and not key:
+        raise CreativeGenerationError(
+            f"Configure a API key do provider LLM '{provider}' em Configurações Técnicas > API Keys."
+        )
+    return provider, key, base_url.rstrip("/"), model
+
+
+@lru_cache(maxsize=1)
+def reference_bundle() -> str:
+    sections: list[str] = []
+    for label, filename in REFERENCE_FILES.items():
+        path = REFERENCES_DIR / filename
+        try:
+            content = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        # Keep prompts bounded while preserving the concrete rules from the attachments.
+        sections.append(f"[{label}]\n{content[:4200]}")
+    return "\n\n".join(sections)
+
+
+def _json_content(payload: dict[str, Any]) -> dict[str, Any]:
+    choices = payload.get("choices") or []
+    if not choices:
+        raise CreativeGenerationError("O endpoint LLM devolveu uma resposta sem choices.")
+    message = (choices[0] or {}).get("message") or {}
+    content = message.get("content")
+    if isinstance(content, list):
+        content = "".join(str(item.get("text", "")) for item in content if isinstance(item, dict))
+    text = str(content or "").strip()
+    text = re.sub(r"^```(?:json)?\s*", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\s*```$", "", text).strip()
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise CreativeGenerationError("O endpoint LLM não devolveu JSON válido.") from exc
+    if not isinstance(parsed, dict):
+        raise CreativeGenerationError("A resposta do endpoint LLM não é um objecto JSON.")
+    return parsed
+
+
+def _chat_json(settings: dict[str, Any], system_prompt: str, user_prompt: str) -> dict[str, Any]:
+    _provider, api_key, base_url, model = _provider_config(settings)
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    body = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        "response_format": {"type": "json_object"},
+    }
+    endpoint = f"{base_url}/chat/completions"
+    try:
+        response = requests.post(endpoint, headers=headers, json=body, timeout=120)
+    except requests.RequestException as exc:
+        raise CreativeGenerationError(f"Não foi possível contactar o provider LLM: {exc}") from exc
+    if response.status_code >= 400:
+        detail = response.text[:500].replace(api_key, "[REDACTED]") if api_key else response.text[:500]
+        raise CreativeGenerationError(f"O provider LLM devolveu HTTP {response.status_code}: {detail}")
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise CreativeGenerationError("O provider LLM devolveu uma resposta que não é JSON.") from exc
+    return _json_content(payload)
+
+
+def channel_context(channel: dict[str, Any], blueprint: dict[str, Any] | None = None) -> dict[str, Any]:
+    blueprint = blueprint or {}
+    metadata = blueprint.get("metadata") if isinstance(blueprint.get("metadata"), dict) else {}
+    return {
+        "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"),
+        "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"),
+        "blueprint_niche": str(blueprint.get("target_niche") or blueprint.get("niche") or metadata.get("target_niche") or metadata.get("niche") or ""),
+        "default_voice": str(channel.get("default_voice") or channel.get("voice") or ""),
+    }
+
+
+def generate_topic_for_channel(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    blueprint: dict[str, Any] | None = None,
+    user_context: str = "",
+) -> dict[str, Any]:
+    context = channel_context(channel, blueprint)
+    system = (
+        "És o estratega editorial de um canal faceless. Gera um briefing específico para este canal. "
+        "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."
+    )
+    user = json.dumps(
+        {
+            "channel": context,
+            "user_context": user_context.strip(),
+            "reference_rules": reference_bundle(),
+            "requirements": [
+                "topic em uma frase clara",
+                "angle contrarian ou inesperado quando fizer sentido",
+                "hook para os primeiros segundos",
+                "niche coerente com o Blueprint e descrição",
+                "rationale curta e prática",
+            ],
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    required = ("topic", "angle", "hook", "niche", "rationale")
+    if any(not str(result.get(key) or "").strip() for key in required):
+        raise CreativeGenerationError("O briefing gerado veio incompleto; tente novamente.")
+    result["topic_source"] = "llm"
+    result["channel_id"] = str(channel.get("id") or "")
+    return result
+
+
+def _score(value: Any) -> int:
+    try:
+        return max(0, min(3, int(value)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _short_overlay(value: Any) -> str:
+    words = re.findall(r"\S+", str(value or "").strip())
+    return " ".join(words[:4])
+
+
+def generate_creative_package(
+    settings: dict[str, Any],
+    channel: dict[str, Any],
+    topic: str,
+    blueprint: dict[str, Any] | None = None,
+    language: str = "",
+) -> dict[str, Any]:
+    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)
+    system = (
+        "És director editorial e de thumbnails para YouTube. Cria um pacote coerente de título e thumbnail "
+        "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, texto opcional de até 4 palavras, "
+        "safe zones e leitura em 120px. O texto da thumbnail não pode repetir o título integralmente. Remove AI tells. "
+        "Responde apenas com JSON válido nas chaves selected_title, title_candidates e thumbnail_variants."
+    )
+    user = json.dumps(
+        {
+            "channel": context,
+            "language": language or context["language"],
+            "topic": topic.strip(),
+            "reference_rules": reference_bundle(),
+            "title_candidates_schema": {
+                "title": "string",
+                "formula": "string",
+                "curiosity_score": "integer 0-3",
+                "specificity_score": "integer 0-3",
+                "emotional_score": "integer 0-3",
+            },
+            "thumbnail_variant_schema": {
+                "concept": "string",
+                "overlay_text": "string, maximum 4 words",
+                "composition": "string",
+                "color_palette": "string",
+                "subject": "string",
+                "image_prompt": "string, no text rendered in the image",
+                "title_synergy": "string",
+            },
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    raw_titles = result.get("title_candidates")
+    if not isinstance(raw_titles, list) or len(raw_titles) < 20:
+        raise CreativeGenerationError("O provider deve devolver pelo menos 20 títulos candidatos.")
+    titles: list[dict[str, Any]] = []
+    for item in raw_titles[:30]:
+        if not isinstance(item, dict) or not str(item.get("title") or "").strip():
+            continue
+        title = str(item["title"]).strip()
+        titles.append(
+            {
+                "title": title,
+                "formula": str(item.get("formula") or "custom").strip(),
+                "curiosity_score": _score(item.get("curiosity_score")),
+                "specificity_score": _score(item.get("specificity_score")),
+                "emotional_score": _score(item.get("emotional_score")),
+            }
+        )
+    if len(titles) < 20:
+        raise CreativeGenerationError("Os títulos devolvidos pelo provider não têm conteúdo suficiente.")
+    variants_raw = result.get("thumbnail_variants")
+    if not isinstance(variants_raw, list) or len(variants_raw) < 3:
+        raise CreativeGenerationError("O provider deve devolver pelo menos 3 variantes de thumbnail.")
+    variants: list[dict[str, Any]] = []
+    for item in variants_raw[:5]:
+        if not isinstance(item, dict):
+            continue
+        if not str(item.get("concept") or "").strip() or not str(item.get("image_prompt") or "").strip():
+            continue
+        variants.append(
+            {
+                "concept": str(item.get("concept") or "").strip(),
+                "overlay_text": _short_overlay(item.get("overlay_text")),
+                "composition": str(item.get("composition") or "").strip(),
+                "color_palette": str(item.get("color_palette") or "").strip(),
+                "subject": str(item.get("subject") or "").strip(),
+                "image_prompt": str(item.get("image_prompt") or "").strip(),
+                "title_synergy": str(item.get("title_synergy") or "").strip(),
+                "status": "prompt_ready",
+            }
+        )
+    if len(variants) < 3:
+        raise CreativeGenerationError("As variantes de thumbnail devolvidas pelo provider estão incompletas.")
+    selected_title = str(result.get("selected_title") or titles[0]["title"]).strip()
+    if selected_title not in {item["title"] for item in titles}:
+        selected_title = titles[0]["title"]
+    return {
+        "title": selected_title,
+        "title_candidates": titles,
+        "thumbnail_variant": variants[0],
+        "thumbnail_variants": variants,
+        "thumbnail_status": "prompt_ready",
+        "topic_source": "llm",
+        "generated_by": "configured_llm",
+    }

package/hermes_ui/domain.py

@@ -108,39 +108,66 @@ def create_batch(mode: str, channel_ids: list[str], topic: str, quantity: int, o
 
 
 def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
+    """Expand a batch into tasks, allowing independent payloads for each channel."""
     tasks = read_json("tasks.json", [])
     channels = {c["id"]: c for c in read_json("channels.json", [])}
-    target_channels = batch["channel_ids"]
-    count = batch["quantity"]
-    if batch["mode"] == "general":
+    options = batch.get("options") or {}
+    channel_payloads = options.get("channel_payloads") or {}
+    target_channels = batch.get("channel_ids") or []
+    count = max(1, int(batch.get("quantity") or 1))
+    if batch.get("mode") == "general":
         count = 1
     created: list[dict[str, Any]] = []
     for channel_id in target_channels:
+        channel = channels.get(channel_id, {})
+        payload = channel_payloads.get(channel_id) if isinstance(channel_payloads, dict) else None
+        payload = payload if isinstance(payload, dict) else {}
         for index in range(count):
-            channel = channels.get(channel_id, {})
+            default_topic = str(batch.get("topic") or "").strip()
+            if count == 1:
+                topic = str(payload.get("topic") or default_topic).strip()
+            else:
+                topic = str(payload.get("topic") or f"{default_topic} — variação {index + 1}").strip()
+            if not topic:
+                topic = f"Vídeo para {channel.get('name', 'Canal')}"
+            title = str(payload.get("title") or topic).strip()
+            artifacts = dict(payload.get("artifacts") or {})
+            thumbnail_path = str(payload.get("thumbnail_path") or "").strip()
+            if thumbnail_path:
+                artifacts.setdefault("thumbnail", thumbnail_path)
             task = {
                 "id": make_id("video"),
                 "batch_id": batch["id"],
-                "creation_mode": batch["mode"],
+                "creation_mode": batch.get("mode", "single"),
                 "channel_id": channel_id,
                 "channel_name": channel.get("name", "Canal"),
-                "topic": batch["topic"] if count == 1 else f"{batch['topic']} — variação {index + 1}",
-                "language": batch["options"].get("language", channel.get("language", "Português")),
-                "format": batch["options"].get("format", "wide"),
-                "style_wide": batch["options"].get("style_wide", channel.get("style_wide", "pexels")),
-                "style_ia": batch["options"].get("style_ia", ""),
-                "music_mode": batch["options"].get("music_mode", False),
-                "music_path": batch["options"].get("music_path", ""),
-                "music_source": batch["options"].get("music_source", ""),
-                "background_mode": batch["options"].get("background_mode", "stock"),
-                "blueprint_id": channel.get("default_blueprint_id") or channel.get("blueprint_id", ""),
-                "voice": channel.get("default_voice") or channel.get("voice", ""),
+                "topic": topic,
+                "title": title,
+                "topic_source": str(payload.get("topic_source") or options.get("topic_source") or "manual"),
+                "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"))),
+                "style_ia": payload.get("style_ia", options.get("style_ia", "")),
+                "music_mode": payload.get("music_mode", options.get("music_mode", False)),
+                "music_path": payload.get("music_path", options.get("music_path", "")),
+                "music_source": payload.get("music_source", options.get("music_source", "")),
+                "background_mode": payload.get("background_mode", options.get("background_mode", "stock")),
+                "blueprint_id": payload.get("blueprint_id") or channel.get("default_blueprint_id") or channel.get("blueprint_id", ""),
+                "blueprint_name": payload.get("blueprint_name", ""),
+                "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"),
+                "thumbnail_variant": payload.get("thumbnail_variant", {}),
+                "thumbnail_variants": payload.get("thumbnail_variants", []),
+                "thumbnail_prompt": payload.get("thumbnail_prompt", ""),
+                "thumbnail_text": payload.get("thumbnail_text", ""),
+                "thumbnail_status": payload.get("thumbnail_status", "not_generated"),
+                "title_candidates": payload.get("title_candidates", []),
+                "ai_generation": payload.get("ai_generation", {}),
                 "stage": "script",
                 "state": "to_do",
                 "progress": 0,
-                "artifacts": {},
+                "artifacts": artifacts,
                 "error": None,
                 "created_at": now(),
                 "updated_at": now(),
@@ -148,10 +175,12 @@ def create_tasks_for_batch(batch: dict[str, Any]) -> list[dict[str, Any]]:
             tasks.append(task)
             created.append(task)
     write_json("tasks.json", tasks)
-    for task in created:
-        queues = read_json("queues.json", {})
-        queues.setdefault("script", []).append(task["id"])
-        write_json("queues.json", queues)
+    queues = read_json("queues.json", {})
+    if not isinstance(queues, dict):
+        queues = {}
+    queues.setdefault("script", [])
+    queues["script"].extend(task["id"] for task in created)
+    write_json("queues.json", queues)
     return created
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.49",
+  "version": "0.2.50",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "main": "scripts/cli.mjs",
   "type": "module",
@@ -17,6 +17,7 @@
     "storage/blueprints/**/*.json",
     "seed/blueprints/**/*.json",
     "seed/skills/*.md",
+    "seed/references/*.md",
     "README.md",
     "MANUAL-INSTALACAO.md",
     "THIRD-PARTY-NOTICES.md",