@danhachuel/thunderbolt 0.2.49 → 0.2.51

package/hermes_ui/automation_worker.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from . import storage
+from .creative_generation import generate_creative_package, generate_topic_for_channel
 from .domain import create_batch, create_tasks_for_batch
 
 WORKER_STATE_FILE = "automation_worker.json"
@@ -127,9 +128,50 @@ def _daily_quantity(channel: dict[str, Any]) -> int:
         return 1
 
 
-def _automation_topic(channel: dict[str, Any]) -> str:
-    topic = str(channel.get("automation_topic") or "").strip()
-    return topic or f"Geração automática — {channel.get('name') or 'Canal'}"
+def _blueprint_for_channel(channel: dict[str, Any]) -> dict[str, Any]:
+    blueprint_id = str(channel.get("default_blueprint_id") or channel.get("blueprint_id") or "").strip()
+    if not blueprint_id:
+        return {}
+    for path in storage.list_blueprint_files():
+        try:
+            data = storage.load_blueprint_file(path)
+        except (OSError, ValueError):
+            continue
+        identifiers = {str(data.get("id") or ""), path.stem, str(data.get("name") or "")}
+        if blueprint_id in identifiers:
+            return data
+    return {}
+
+
+def _creative_payload(channel: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    settings = storage.read_json("settings.json", {})
+    blueprint = _blueprint_for_channel(channel)
+    user_context = str(channel.get("automation_topic") or "").strip()
+    topic_package = generate_topic_for_channel(settings, channel, blueprint, user_context=user_context)
+    creative = generate_creative_package(
+        settings,
+        channel,
+        topic_package["topic"],
+        blueprint,
+        language=str(channel.get("language") or "Português"),
+    )
+    variant = creative["thumbnail_variant"]
+    payload = {
+        "topic": topic_package["topic"],
+        "topic_source": "llm",
+        "title": creative["title"],
+        "title_candidates": creative["title_candidates"],
+        "thumbnail_variant": variant,
+        "thumbnail_variants": creative["thumbnail_variants"],
+        "thumbnail_prompt": variant.get("image_prompt", ""),
+        "thumbnail_text": variant.get("overlay_text", ""),
+        "thumbnail_status": creative.get("thumbnail_status", "prompt_ready"),
+        "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 ""),
+        "ai_generation": {"topic": topic_package, "creative": creative},
+    }
+    return topic_package["topic"], payload
 
 
 def _batch_for_day(channel_id: str, day: str) -> dict[str, Any] | None:
@@ -155,6 +197,7 @@ def _create_channel_batch(channel: dict[str, Any], when: datetime) -> dict[str,
     date_key = when.date().isoformat()
     style_wide = str(channel.get("style_wide") or "pexels")
     music_mode = style_wide == "music"
+    topic, payload = _creative_payload(channel)
     options = {
         "language": channel.get("language") or "Português",
         "format": "wide",
@@ -164,17 +207,13 @@ 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",
+        "channel_payloads": {channel_id: payload},
         "automation_worker": True,
         "automation_date": date_key,
         "automation_scheduled_at": _local_iso(when),
     }
-    batch = create_batch(
-        "single",
-        [channel_id],
-        _automation_topic(channel),
-        _daily_quantity(channel),
-        options,
-    )
+    batch = create_batch("single", [channel_id], topic, _daily_quantity(channel), options)
     tasks = create_tasks_for_batch(batch)
     return {"batch": batch, "tasks": tasks, "channel_id": channel_id}
 

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

@@ -29,6 +29,8 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "url": url.strip(),
         "handle": "",
         "description": "",
+        "niche": "",
+        "reference_channels": [],
         "thumbnail_url": "",
         "subscriber_count": None,
         "video_count": None,
@@ -108,39 +110,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,13 +177,27 @@ 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
 
 
+def update_channel_video(video_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
+    """Actualizar um vídeo remoto sincronizado ou um override local de vídeo do canal."""
+    videos = read_json("channel_videos.json", [])
+    for video in videos:
+        if video.get("id") == video_id:
+            video.update(updates)
+            video["updated_at"] = now()
+            write_json("channel_videos.json", videos)
+            return video
+    return None
+
+
 def update_task(task_id: str, updates: dict[str, Any]) -> dict[str, Any] | None:
     tasks = read_json("tasks.json", [])
     for task in tasks:

package/hermes_ui/storage.py

@@ -16,8 +16,9 @@ NICHES_DATA = STORAGE / "data" / "niches"
 SEED_BLUEPRINTS = ROOT / "seed" / "blueprints"
 
 DEFAULTS: dict[str, Any] = {
-    "channels.json": [],
-    "tasks.json": [],
+        "channels.json": [],
+        "channel_videos.json": [],
+        "tasks.json": [],
     "queues.json": {"niche": [], "blueprint": [], "brand": [], "script": [], "title": [], "thumbnail": [], "video": [], "edit": [], "upload": []},
     "batches.json": [],
     "uploads.json": [],

package/integrations/platforms.py

@@ -238,6 +238,80 @@ def _public_feed_data(channel_id: str, headers: dict[str, str]) -> dict[str, Any
         return {}
 
 
+def fetch_channel_videos_public(channel_ref: str | dict[str, Any], limit: int = 10) -> "IntegrationResult":
+    """Fetch the latest public channel videos from YouTube's Atom feed without an API key."""
+    if isinstance(channel_ref, dict):
+        source = str(channel_ref.get("youtube_channel_id") or channel_ref.get("url") or "").strip()
+    else:
+        source = str(channel_ref or "").strip()
+    if not source:
+        return IntegrationResult(False, "Este canal ainda não tem ID ou URL pública do YouTube.", {"videos": []})
+    headers = {
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124 Safari/537.36",
+        "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+        "Accept": "application/atom+xml,application/xml,text/xml;q=0.9,*/*;q=0.8",
+    }
+    channel_id = _channel_id_from_source(source)
+    if not channel_id and source.startswith(("http://", "https://")):
+        for page_url in _public_page_candidates(source):
+            try:
+                response = requests.get(page_url, headers=headers, timeout=12, allow_redirects=True)
+                response.raise_for_status()
+            except requests.RequestException:
+                continue
+            document = response.text or ""
+            channel_id = _channel_id_from_document(document, str(getattr(response, "url", "") or page_url))
+            if channel_id:
+                break
+    if not channel_id:
+        return IntegrationResult(False, "Não foi possível resolver o ID público do canal para carregar os vídeos.", {"videos": []})
+    feed_url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
+    try:
+        response = requests.get(feed_url, headers=headers, timeout=12)
+        response.raise_for_status()
+        root = ET.fromstring(response.text)
+    except (requests.RequestException, ET.ParseError, ValueError) as exc:
+        return IntegrationResult(False, f"Não foi possível carregar os vídeos públicos do canal: {exc}", {"channel_id": channel_id, "videos": []})
+    namespace = {
+        "yt": "http://www.youtube.com/xml/schemas/2015",
+        "atom": "http://www.w3.org/2005/Atom",
+        "media": "http://search.yahoo.com/mrss/",
+    }
+    videos: list[dict[str, Any]] = []
+    max_items = max(1, min(10, int(limit or 10)))
+    for entry in root.findall("atom:entry", namespace)[:max_items]:
+        video_id = entry.findtext("yt:videoId", default="", namespaces=namespace).strip()
+        title = entry.findtext("atom:title", default="", namespaces=namespace).strip()
+        published_at = entry.findtext("atom:published", default="", namespaces=namespace).strip()
+        updated_at = entry.findtext("atom:updated", default="", namespaces=namespace).strip()
+        link = ""
+        for candidate in entry.findall("atom:link", namespace):
+            if candidate.attrib.get("rel", "alternate") == "alternate":
+                link = candidate.attrib.get("href", "")
+                break
+        if not link and video_id:
+            link = f"https://www.youtube.com/watch?v={video_id}"
+        thumbnail = ""
+        media_group = entry.find("media:group", namespace)
+        if media_group is not None:
+            media_thumbnail = media_group.find("media:thumbnail", namespace)
+            if media_thumbnail is not None:
+                thumbnail = str(media_thumbnail.attrib.get("url", ""))
+        videos.append({
+            "id": f"youtube_{video_id}" if video_id else f"youtube_{len(videos)}",
+            "youtube_video_id": video_id,
+            "channel_id": channel_id,
+            "title": title or "Vídeo sem título",
+            "published_at": published_at,
+            "updated_at": updated_at,
+            "url": link,
+            "thumbnail_url": thumbnail,
+            "source": "youtube_public_rss",
+            "status": "publicado",
+        })
+    return IntegrationResult(True, f"{len(videos)} vídeo(s) público(s) carregado(s) sem API Key.", {"channel_id": channel_id, "videos": videos})
+
+
 @dataclass
 class IntegrationResult:
     ok: bool
@@ -385,6 +459,9 @@ class YouTubeAdapter:
             data["youtube_id"] = direct_id
         return IntegrationResult(False, f"Não foi possível obter dados públicos do YouTube sem API Key. {last_error or 'Confirme o URL/handle ou use Cadastro manual.'}".strip(), data)
 
+    def fetch_channel_videos_public(self, channel_ref: str | dict[str, Any], limit: int = 10) -> IntegrationResult:
+        return fetch_channel_videos_public(channel_ref, limit=limit)
+
     def fetch_channel(self, value: str) -> IntegrationResult:
         ref = self.extract_channel_ref(value)
         if not self.api_key:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "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",