@danhachuel/thunderbolt 0.2.54 → 0.2.55

package/MANUAL-INSTALACAO.md

@@ -2,7 +2,7 @@
 
 Este manual descreve a instalação local da UI Thunderbolt, baseada no MoneyPrinterTurbo, utilizando o pacote npm `@danhachuel/thunderbolt`. O fluxo recomendado instala automaticamente o ambiente Python, as dependências da aplicação, as dependências do MoneyPrinterTurbo, o Streamlit e o suporte FFmpeg através de `imageio-ffmpeg`.
 
-> **Versão deste manual:** 0.2.54
+> **Versão deste manual:** 0.2.55
 > **Pacote npm:** `@danhachuel/thunderbolt`
 > **Porta padrão da UI:** `localhost:3030`  
 > **Repositório:** [github.com/DanHachuel/thunderbolt](https://github.com/DanHachuel/thunderbolt)
@@ -100,13 +100,13 @@ Execute:
 Windows PowerShell ou MobaXterm:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.54 install
+npx --yes @danhachuel/thunderbolt@0.2.55 install
 ```
 
 A instalação normal é **segura para actualizações**: preserva `storage`, Blueprints, Brandings, configurações e artefactos do utilizador. Remove apenas `.venv`, o clone técnico do MoneyPrinterTurbo e dependências que serão recriadas. Uma pasta antiga sem dados do utilizador, como `C:\Users\<utilizador>\AppData\Local\hermes` da tentativa incompleta, pode ser removida; uma pasta antiga que contenha Blueprints, Brandings ou storage é preservada e apenas avisada no terminal. Feche processos Python, Node, Streamlit e MobaXterm que estejam a usar as pastas antes de executar.
@@ -428,7 +428,7 @@ Ao abrir a página, o Thunderbolt não prepara dados públicos, não descarrega
 
 Os parâmetros da UI são número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, engagement, intervalo de datas e tags, todos dentro da área principal da aba. O núcleo normaliza os dados, calcula engagement, aplica filtros, faz transformação logarítmica e standardização, executa K-Means e calcula itemsets/regras com FP-Growth. Não são apresentados resultados até ao primeiro clique em **Analisar Nichos**; o mesmo botão aplica alterações posteriores aos filtros. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados analisados; o gráfico de dispersão é criado nativamente com Plotly.
 
-As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install`; o instalador detecta e reutiliza o que já estiver válido.
+As dependências adicionais — `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub` — são instaladas pelo procedimento normal de `npx`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -458,10 +458,12 @@ Depois do tópico, clique em **Gerar títulos e thumbnails com IA**. O Thunderbo
 
 No modo **Lote geral**, todos os canais cadastrados são incluídos automaticamente. Não existe selector **Canais incluídos**. O Thunderbolt cria exactamente uma task por canal e cada task recebe briefing, título, thumbnail, Blueprint, voz e contexto próprios. O mesmo tópico não é replicado entre canais.
 
-## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
+## Pipeline: Criação de Vídeos, Criação de Músicas, Roteiros e Automação
 
 O modo `Pexels/Pixabay` representa materiais de stock. Ao seleccionar `full_ia`, o selector `Estilo IA` apresenta os 12 estilos disponíveis. Ao seleccionar `Apenas Música`, a UI obriga a escolher uma música existente, carregar um ficheiro ou solicitar uma música a um endpoint Suno configurado. O vídeo recebe `background_mode=none`, sem fundo Pexels/Pixabay ou IA.
 
+A aba **Roteiros**, colocada entre **Criação de Músicas** e **Upload**, permite seleccionar um canal opcional, um Blueprint, **Roteiro de vídeo** ou **Letra de música**, idioma, tema e estrutura. O botão **Gerar com IA a partir do Blueprint** usa o provider LLM configurado e devolve um rascunho Markdown editável; o utilizador deve rever e clicar em **Guardar documento no storage**. Os ficheiros são guardados em `storage/scripts/` e o índice em `storage/state/scripts.json`; o caminho absoluto aparece no topo da página. Na subaba **Vídeos** de **Criação de Vídeos**, a aplicação mostra a frase `Os vídeos são guardados em <storage>/videos`, que identifica a pasta local dos vídeos.
+
 A aba **Automação Youtube**, dentro do menu expansível **Automação**, lista os canais e vídeos, permite escolher e guardar **Blueprint padrão** e **Voz padrão** por canal, guarda **Automação ON** e valida horários diários no formato `HH:MM`. Os valores ficam sincronizados com o editor existente no cartão da aba **Canais Youtube** e são copiados para novas tarefas. O launcher inicia o worker local, que consulta o relógio do computador, gera um briefing, título e pacote de thumbnail específicos com o provider LLM configurado, cria o lote agendado na fila e evita duplicar o mesmo canal no mesmo dia. Se a geração não puder ser executada, o erro fica registado e o placeholder antigo não é usado.
 
 A área **Teste de vozes**, dentro de **Configurações > Configurações Técnicas**, é isolada da pipeline. O preview pode ser reproduzido e descarregado de `storage/voice_previews/`. Caminhos vazios, directórios, ficheiros vazios e previews sem permissões de leitura são ignorados com uma mensagem clara, sem traceback. Se uma instalação antiga mostrar que `edge-tts` está em falta, execute `npx.cmd --yes @danhachuel/thunderbolt install`; o detector reinstala apenas a dependência ausente.

package/README.md

@@ -11,7 +11,7 @@ A primeira versão implementa a camada UI independente com:
 | Área | Incluído |
 |---|---|
 | Início | Resumo de canais, tarefas, backlog, execução e falhas, com as filas do Pipeline inline |
-| Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas e Upload |
+| Pipeline | Menu expansível com Criação de Vídeos, Criação de Músicas, Roteiros e Upload |
 | Blueprints Youtube | Leitura da pasta `storage/blueprints/`, upload/validação de JSON e criação a partir de link YouTube |
 | Brandings | Subaba própria dentro de Blueprints, upload/listagem de Brandings e criação conjunta com Blueprint |
 | Canais Youtube | Subabas de importação pública sem API Key, Canais em lote gmail por conta Google/YouTube via OAuth e cadastro manual independente; cartões com botão Editar, nicho/referências visível, Prompts do Canal/Blueprint, Narrador/voz e gestão dos últimos 10 vídeos |
@@ -38,9 +38,9 @@ Os dados são segredos de sessão. Os valores não aparecem em tabelas ou logs,
 
 Os adaptadores do MoneyPrinterTurbo e de publicação nas plataformas são ligados pelas configurações locais e pelos pontos de integração em `integrations/`. A UI não inventa dados quando um serviço externo ou credencial não está disponível.
 
-## Navegação da UI 0.2.54
+## Navegação da UI 0.2.55
 
-A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas** e **Upload**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
+A barra lateral mantém os níveis principais, nesta ordem: **Início**, **Niche Finder**, **Pipeline**, **Automação**, **Edição**, **Models AI** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Roteiros** e **Upload**. **Automação** também é expansível e contém **Automação Youtube**. **Edição** é expansível e contém **Limpador de Metadados**, **Cortes** e **Editor Python**, nessa ordem. **Models AI** é expansível e contém **Personagens** e **Redes Sociais**, nessa ordem. **Niche Finder** é expansível e contém **Niche Finder Kaggle** e **Niche Finder Apify**. **Configurações** é expansível e contém **Canais Youtube**, **Blueprints Youtube**, **MCP** e **Configurações Técnicas**. O Início reúne o dashboard e as filas do Pipeline, sem botões de acções rápidas.
 
 Dentro de **Configurações Técnicas**, a UI está organizada em três subabas, sem numeração visível: **Contas Google/YouTube — canais em lote**, **API Keys** e **Teste de vozes**. A primeira contém cartões expansíveis de contas Google, sessionInfo e documentos de Upload directo; o formulário **Adicionar outra conta Gmail** fica fora dos cartões. **API Keys** reúne execução local, OAuth, LLM, TTS, materiais e restantes credenciais; **Teste de vozes** contém exclusivamente o preview de áudio.
 
@@ -161,9 +161,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.54
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.55
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -187,7 +187,7 @@ O menu expansível **Niche Finder** contém duas alternativas independentes. **N
 
 A interface apresenta dentro da aba os parâmetros da busca: número de clusters entre 2 e 10, suporte mínimo entre 0,01 e 0,50, país, categoria de engagement, intervalo de datas e tags. A página permanece sem resultados até o primeiro clique em **Analisar Nichos**; depois, se os parâmetros forem alterados, mostra os resultados anteriores e pede novo clique para aplicar os filtros actuais. O núcleo aplica normalização, filtros, `log1p`, `StandardScaler`, K-Means e FP-Growth. Os resultados aparecem em DataFrames para clusters, itemsets frequentes, regras de associação e dados analisados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters.
 
-**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install`; o instalador detecta e reutiliza componentes já válidos.
+**Niche Finder Apify** é a segunda alternativa e não usa o dataset, filtros, execução ou resultados Kaggle. Define três palavras-chave, período, limite de resultados, Shorts, duração, idioma de legendas e ordenação; depois de clicar em **Pesquisar no Apify**, inicia o actor `streamers~youtube-scraper`, acompanha o run, carrega o dataset, normaliza vídeos, limpa SRT, calcula VSC Ratio e tenta resumir as transcrições com o provider LLM configurado. Os resultados ficam na sessão própria `niche_apify_results`, o histórico pequeno fica em `storage/state/niche_apify_runs.json` e existem exportações JSON/CSV. Configure o **Apify API Token** em Configurações Técnicas. As dependências adicionais são instaladas pelo fluxo normal do pacote: `requests`, `pandas` e os componentes já existentes da análise. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.55 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 
@@ -268,6 +268,10 @@ A subaba **Upload directo** adapta o [YouTube-Video-Upload-Frontend-Api](https:/
 
 Em **Criação de Vídeos**, o estilo visual `Pexels/Pixabay` é o modo de materiais, `full_ia` abre o selector **Estilo IA** com os 12 estilos solicitados e **Apenas Música** exige um áudio local, um upload musical ou um pedido ao endpoint Suno configurado. **Criação de Músicas** reutiliza o mesmo conteúdo e formulário com título próprio. Neste último modo, a task fica com `background_mode=none`: não são gerados fundos Pexels/Pixabay nem fundos IA.
 
+A subaba **Roteiros**, entre **Criação de Músicas** e **Upload**, permite escolher um canal opcional, um Blueprint, o tipo **Roteiro de vídeo** ou **Letra de música**, idioma, briefing e notas de estrutura. O botão **Gerar com IA a partir do Blueprint** usa o provider LLM configurado, devolve um rascunho Markdown editável e só guarda o documento quando o utilizador confirmar. Os ficheiros ficam em `storage/scripts/` e o índice do histórico em `storage/state/scripts.json`; a própria página mostra o caminho absoluto correspondente ao storage local.
+
+Na subaba **Vídeos** de **Criação de Vídeos**, a frase `Os vídeos são guardados em <storage>/videos` identifica a pasta real onde os artefactos de vídeo devem ser procurados.
+
 O agente musical guarda os ficheiros em `storage/music/`, aceita formatos de áudio comuns e pode descarregar uma URL de áudio devolvida por um endpoint Suno compatível. Em **Canais Youtube**, abra **Definir Blueprint e voz padrão** no cartão do canal para guardar os defaults; em **Automação Youtube**, os mesmos dois selectores aparecem no cartão e são sincronizados. Esses valores são usados automaticamente em novas tarefas criadas para o canal. A aba **Automação Youtube** também guarda `Automação ON` e um horário diário `HH:MM` por canal e lista os vídeos cadastrados; por definição, esta entrega não executa workers de fundo.
 
 ## Teste de vozes

package/app/main.py

@@ -34,6 +34,8 @@ from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips,
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
 from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
+from hermes_ui.script_documents import list_script_documents, read_script_document, save_script_document, script_storage_path
+from hermes_ui.script_generation import generate_script_document
 from hermes_ui.voice_preview import DEFAULT_SAMPLE, load_preview_file, synthesize_preview
 from hermes_ui.creative_generation import CreativeGenerationError, generate_creative_package, generate_topic_for_channel
 from integrations.platforms import IntegrationResult, TikTokAdapter, YouTubeAdapter, fetch_channel_videos_public
@@ -1239,6 +1241,150 @@ def render_music_creation():
     render_new_video(page_title="Criação de Músicas")
 
 
+def render_scripts():
+    st.title("Roteiros")
+    st.caption("Produza e guarde roteiros de vídeos ou letras de músicas a partir dos Blueprints do Thunderbolt.")
+    script_dir = script_storage_path()
+    st.info(f"**Ficheiros guardados em:** `{script_dir}` · o conteúdo fica no storage local do Thunderbolt e não é enviado automaticamente para plataformas.")
+
+    create_tab, history_tab = st.tabs(["Novo roteiro/letra", "Histórico guardado"])
+    with create_tab:
+        all_channels = [channel for channel in read_json("channels.json", []) if isinstance(channel, dict)]
+        active_channels = [channel for channel in all_channels if channel.get("active", True)]
+        channel_options: list[dict[str, Any] | None] = [None] + active_channels
+        selected_channel = st.selectbox(
+            "Canal (opcional)",
+            channel_options,
+            format_func=lambda channel: "Documento independente" if channel is None else str(channel.get("name") or "Canal sem nome"),
+            key="script_channel",
+        )
+        blueprint_options = blueprint_catalog()
+        blueprint_ids = [identifier for identifier, _label in blueprint_options]
+        blueprint_labels = {identifier: label for identifier, label in blueprint_options}
+        selected_blueprint_id = st.selectbox(
+            "Blueprint",
+            blueprint_ids,
+            format_func=lambda identifier: blueprint_labels.get(identifier, "Sem Blueprint padrão"),
+            key="script_blueprint",
+        )
+        selected_blueprint: dict[str, Any] = {}
+        if selected_blueprint_id:
+            for path in list_blueprint_files():
+                try:
+                    blueprint = load_blueprint_file(path)
+                except (OSError, ValueError, json.JSONDecodeError):
+                    continue
+                identifiers = {str(blueprint.get("id") or ""), path.stem, str(blueprint.get("name") or "")}
+                if selected_blueprint_id in identifiers:
+                    selected_blueprint = dict(blueprint)
+                    selected_blueprint.setdefault("id", selected_blueprint_id)
+                    selected_blueprint.setdefault("name", blueprint_labels.get(selected_blueprint_id, selected_blueprint_id))
+                    break
+        if selected_blueprint:
+            st.caption(f"Blueprint aplicado ao contexto: **{selected_blueprint.get('name', selected_blueprint_id)}**")
+        else:
+            st.warning("Sem Blueprint seleccionado: o documento pode ser criado, mas não terá contexto editorial de Blueprint.")
+
+        document_type = st.radio("Tipo de documento", ["Roteiro de vídeo", "Letra de música"], horizontal=True, key="script_document_type")
+        title = st.text_input("Título", key="script_title", placeholder="Ex.: A verdade esquecida sobre…")
+        brief = st.text_area(
+            "Tema ou briefing",
+            key="script_brief",
+            height=120,
+            placeholder="Descreva o tema, a mensagem, o conflito ou a ideia musical que o Blueprint deve orientar.",
+        )
+        language_options = VIDEO_LANGUAGE_OPTIONS
+        language = st.selectbox("Idioma", language_options, key="script_language")
+        structure_notes = st.text_area(
+            "Estrutura e notas opcionais",
+            key="script_structure_notes",
+            height=90,
+            placeholder="Ex.: 6 cenas, narração documental, refrão repetível, atmosfera sombria…",
+        )
+        generate_col, clear_col = st.columns([1.4, 1])
+        with generate_col:
+            generate_clicked = st.button("Gerar com IA a partir do Blueprint", type="primary", use_container_width=True, key="generate_script_document")
+        with clear_col:
+            clear_clicked = st.button("Limpar rascunho", use_container_width=True, key="clear_script_document")
+        if clear_clicked:
+            for key in ("script_draft", "script_draft_title", "script_draft_content", "script_draft_summary"):
+                st.session_state.pop(key, None)
+            st.rerun()
+        if generate_clicked:
+            try:
+                with st.spinner("A gerar o documento com o provider LLM configurado…"):
+                    generated = generate_script_document(
+                        read_json("settings.json", {}),
+                        document_type=document_type,
+                        title=title,
+                        brief=brief,
+                        language=language,
+                        channel=selected_channel or {},
+                        blueprint=selected_blueprint,
+                        structure_notes=structure_notes,
+                    )
+                st.session_state["script_draft"] = generated
+                st.session_state["script_draft_title"] = generated["title"]
+                st.session_state["script_draft_summary"] = generated.get("summary", "")
+                st.session_state["script_draft_content"] = generated["content"]
+                st.success("Rascunho gerado. Reveja e edite o texto antes de guardar.")
+            except CreativeGenerationError as exc:
+                st.error(str(exc))
+
+        draft = st.session_state.get("script_draft")
+        if draft:
+            st.divider()
+            st.subheader("Rascunho editável")
+            if "script_draft_title" not in st.session_state:
+                st.session_state["script_draft_title"] = str(draft.get("title") or title or "Documento")
+            if "script_draft_summary" not in st.session_state:
+                st.session_state["script_draft_summary"] = str(draft.get("summary") or "")
+            if "script_draft_content" not in st.session_state:
+                st.session_state["script_draft_content"] = str(draft.get("content") or "")
+            draft_title = st.text_input("Título do rascunho", key="script_draft_title")
+            draft_summary = st.text_input("Resumo", key="script_draft_summary")
+            draft_content = st.text_area("Conteúdo guardado", height=460, key="script_draft_content")
+            if st.button("Guardar documento no storage", type="primary", use_container_width=True, key="save_script_document"):
+                try:
+                    record = save_script_document(
+                        {
+                            **draft,
+                            "title": draft_title,
+                            "summary": draft_summary,
+                            "content": draft_content,
+                            "document_type": "video_script" if document_type == "Roteiro de vídeo" else "music_lyrics",
+                            "language": language,
+                            "channel_id": str((selected_channel or {}).get("id") or ""),
+                            "channel_name": str((selected_channel or {}).get("name") or "Documento independente"),
+                            "blueprint_id": str(selected_blueprint.get("id") or selected_blueprint_id or ""),
+                            "blueprint_name": str(selected_blueprint.get("name") or blueprint_labels.get(selected_blueprint_id, "SEM BLUEPRINT CONFIGURADO")),
+                        }
+                    )
+                    st.success(f"Documento guardado em `{record['path']}`.")
+                except (OSError, ValueError) as exc:
+                    st.error(f"Não foi possível guardar o documento: {exc}")
+        else:
+            st.caption("Gere um rascunho com IA para o editar aqui, ou seleccione um Blueprint e preencha o briefing para começar.")
+
+    with history_tab:
+        st.caption(f"Histórico persistente: `{script_dir}` · índice em `{STORAGE / 'state' / 'scripts.json'}`")
+        records = list_script_documents()
+        if not records:
+            st.info("Ainda não existem roteiros ou letras guardados.")
+        for record in records[:50]:
+            label = f"{record.get('title', 'Documento')} · {record.get('document_type', 'documento')}"
+            with st.expander(label, expanded=False):
+                st.caption(f"{record.get('created_at', '—')} · {record.get('channel_name', 'Documento independente')} · Blueprint: {record.get('blueprint_name', '—')}")
+                stored_path = Path(str(record.get("path") or ""))
+                content = read_script_document(record)
+                if content:
+                    st.text_area("Conteúdo", value=content, height=220, key=f"stored_script_{record.get('id')}")
+                    if stored_path.is_file():
+                        st.download_button("Descarregar Markdown", data=stored_path.read_bytes(), file_name=stored_path.name, mime="text/markdown", key=f"download_script_{record.get('id')}")
+                else:
+                    st.warning("O ficheiro deste registo já não está disponível no storage.")
+
+
 @st.cache_data(show_spinner=False)
 def _cached_niche_download():
     """Download or reuse the dataset only after the user submits the form."""
@@ -1809,6 +1955,7 @@ def render_python_editor():
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")
+    st.caption(f"Os vídeos são guardados em `{STORAGE / 'videos'}`.")
     tasks = read_json("tasks.json", [])
     if not tasks:
         st.info("Nenhum vídeo criado.")
@@ -2782,6 +2929,7 @@ def main():
     pipeline_items = [
         ("Criação de Vídeos", ":material/add_circle:", "Criação de Vídeos"),
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
+        ("Roteiros", ":material/article:", "Roteiros"),
         ("Upload", ":material/cloud_upload:", "Upload"),
     ]
     edition_items = [
@@ -2874,6 +3022,7 @@ def main():
         "Início": render_dashboard,
         "Criação de Vídeos": render_new_video,
         "Criação de Músicas": render_music_creation,
+        "Roteiros": render_scripts,
         "Automação Youtube": render_automation,
         "Niche Finder Kaggle": render_niche_finder,
         "Niche Finder Apify": render_niche_finder_apify,

package/hermes_ui/script_documents.py

@@ -0,0 +1,82 @@
+"""Local Markdown storage for Thunderbolt scripts and music lyrics."""
+
+from __future__ import annotations
+
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .storage import STORAGE, append_json, ensure_storage, read_json, write_json
+
+SCRIPT_HISTORY_FILE = "scripts.json"
+
+
+def _slug(value: str, fallback: str = "documento") -> str:
+    normalized = re.sub(r"[^a-zA-Z0-9À-ÿ]+", "-", str(value or "").strip(), flags=re.UNICODE).strip("-").lower()
+    return (normalized or fallback)[:90]
+
+
+def script_storage_path() -> Path:
+    ensure_storage()
+    path = STORAGE / "scripts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def save_script_document(document: dict[str, Any]) -> dict[str, Any]:
+    content = str(document.get("content") or "").strip()
+    if not content:
+        raise ValueError("O documento não pode ser guardado vazio.")
+    created_at = datetime.now(timezone.utc).isoformat()
+    document_id = str(document.get("id") or uuid.uuid4().hex[:12])
+    title = str(document.get("title") or "Documento").strip()
+    document_type = str(document.get("document_type") or "video_script").strip()
+    prefix = "roteiro" if document_type == "video_script" else "letra"
+    filename = f"{prefix}-{_slug(title)}-{document_id}.md"
+    path = script_storage_path() / filename
+    front_matter = [
+        "---",
+        f"id: {document_id}",
+        f"type: {document_type}",
+        f"title: {title}",
+        f"language: {str(document.get('language') or '')}",
+        f"channel: {str(document.get('channel_name') or '')}",
+        f"blueprint: {str(document.get('blueprint_name') or '')}",
+        f"created_at: {created_at}",
+        "---",
+        "",
+    ]
+    summary = str(document.get("summary") or "").strip()
+    if summary:
+        front_matter.extend([f"> {summary}", ""])
+    path.write_text("\n".join(front_matter) + content.rstrip() + "\n", encoding="utf-8")
+    record = {
+        **document,
+        "id": document_id,
+        "title": title,
+        "document_type": document_type,
+        "path": str(path),
+        "filename": filename,
+        "created_at": created_at,
+        "content": content,
+    }
+    history = read_json(SCRIPT_HISTORY_FILE, [])
+    if not isinstance(history, list):
+        history = []
+    history.insert(0, {key: value for key, value in record.items() if key != "content"})
+    write_json(SCRIPT_HISTORY_FILE, history[:200])
+    return record
+
+
+def list_script_documents() -> list[dict[str, Any]]:
+    history = read_json(SCRIPT_HISTORY_FILE, [])
+    return [item for item in history if isinstance(item, dict)] if isinstance(history, list) else []
+
+
+def read_script_document(record: dict[str, Any]) -> str:
+    path = Path(str(record.get("path") or ""))
+    if not path.is_file():
+        return ""
+    return path.read_text(encoding="utf-8")

package/hermes_ui/script_generation.py

@@ -0,0 +1,91 @@
+"""Blueprint-aware generation of video scripts and music lyrics."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .creative_generation import CreativeGenerationError, _chat_json, channel_context
+
+
+DOCUMENT_TYPES = {
+    "Roteiro de vídeo": "video_script",
+    "Letra de música": "music_lyrics",
+}
+
+
+def generate_script_document(
+    settings: dict[str, Any],
+    *,
+    document_type: str,
+    title: str,
+    brief: str,
+    language: str,
+    channel: dict[str, Any] | None = None,
+    blueprint: dict[str, Any] | None = None,
+    structure_notes: str = "",
+) -> dict[str, Any]:
+    """Generate an editable Markdown document from the configured LLM.
+
+    The function deliberately returns text only. It never writes to storage; the UI
+    decides whether the generated draft should be saved after the user reviews it.
+    """
+    normalized_type = DOCUMENT_TYPES.get(document_type, document_type)
+    if normalized_type not in {"video_script", "music_lyrics"}:
+        raise CreativeGenerationError("Escolha Roteiro de vídeo ou Letra de música.")
+    if not brief.strip():
+        raise CreativeGenerationError("Escreva um tema ou briefing antes de gerar o documento.")
+
+    channel_context_value = channel_context(channel or {}, blueprint or {})
+    blueprint_payload = blueprint or {}
+    if normalized_type == "video_script":
+        output_requirements = {
+            "content": "roteiro completo em Markdown, com título, gancho, cenas, narração e indicações visuais/sonoras",
+            "summary": "resumo editorial em uma frase",
+        }
+        system = (
+            "És um roteirista editorial de vídeos faceless. Cria um roteiro original, natural e executável, "
+            "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."
+        )
+    else:
+        output_requirements = {
+            "content": "letra completa em Markdown, com secções [Verso], [Pré-refrão], [Refrão], [Ponte] quando fizer sentido",
+            "summary": "resumo da intenção musical em uma frase",
+        }
+        system = (
+            "És um compositor de letras originais. Cria uma letra cantável, coerente com o tema, idioma, "
+            "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."
+        )
+
+    user = json.dumps(
+        {
+            "document_type": normalized_type,
+            "requested_title": title.strip(),
+            "brief": brief.strip(),
+            "language": language.strip(),
+            "channel": channel_context_value,
+            "blueprint": blueprint_payload,
+            "structure_notes": structure_notes.strip(),
+            "output_requirements": output_requirements,
+        },
+        ensure_ascii=False,
+    )
+    result = _chat_json(settings, system, user)
+    content = str(result.get("content") or "").strip()
+    if not content:
+        raise CreativeGenerationError("O provider LLM devolveu um documento sem conteúdo.")
+    return {
+        "document_type": normalized_type,
+        "title": str(result.get("title") or title or brief).strip(),
+        "summary": str(result.get("summary") or "").strip(),
+        "content": content,
+        "language": language.strip(),
+        "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 ""),
+        "channel_name": str((channel or {}).get("name") or "Documento independente"),
+        "generated_by": "configured_llm",
+    }

package/hermes_ui/storage.py

@@ -24,8 +24,9 @@ DEFAULTS: dict[str, Any] = {
     "uploads.json": [],
     "niche_apify_runs.json": [],
     "metadata_edits.json": [],
-    "python_editor_edits.json": [],
-    "mcp_server.json": {
+        "python_editor_edits.json": [],
+        "scripts.json": [],
+        "mcp_server.json": {
         "enabled": False,
         "host": "127.0.0.1",
         "port": 3031,

package/package.json

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