@danhachuel/thunderbolt 0.2.53 → 0.2.54

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.53
+> **Versão deste manual:** 0.2.54
 > **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.53 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.54 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.53 install
+npx --yes @danhachuel/thunderbolt@0.2.54 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.53 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.54 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ### Niche Finder Apify
 
@@ -440,7 +440,7 @@ O menu **Models AI** foi adicionado abaixo de **Edição**. As abas **Personagen
 
 ## Edição: Limpador de Metadados, Cortes e Editor Python
 
-A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. A aba **Cortes** permanece reservada e não executa operações. A aba **Editor Python** é funcional e permite escolher vídeos gerados, indicar uma pasta local ou fazer upload manual; as operações são manuais e criam cópias sem alterar os originais.
+A aba **Limpador de Metadados** continua funcional e foi movida para **Edição**. A aba **Cortes** é um Clip Generator local inspirado no [OpenShorts](https://github.com/mutonby/openshorts): permite upload de vídeo, URL directa, vídeos gerados ou pasta local, formatos 9:16/1:1/16:9, opções avançadas, modo manual ou automático por segmentos locais e confirmação de direitos antes da geração. Os clips são processados com FFmpeg, guardados em `storage/cuts/runs/<id>/`, apresentados com preview e downloads individual/ZIP, acompanhados de manifesto JSON e histórico. A aba **Editor Python** é funcional e permite escolher vídeos gerados, indicar uma pasta local ou fazer upload manual; as operações são manuais e criam cópias sem alterar os originais.
 
 ## Editor Python baseado no PYEdit
 
@@ -448,6 +448,8 @@ O **Editor Python** adapta o recorte do [PYEdit](https://github.com/Congren/PYEd
 
 Cada operação usa FFmpeg local, preserva o original, cria a saída em `storage/python_editor/outputs/`, guarda o histórico em `storage/state/python_editor_edits.json` e permite descarregar o resultado e um manifesto JSON. Na subaba **Código Python**, pode criar e guardar scripts em `storage/python_editor/scripts/` ou carregar scripts existentes. Por segurança, a UI não executa código Python e não executa scripts automaticamente.
 
+No modo automático de **Cortes**, a aplicação não inventa uma selecção viral: sem transcrição ou provider de IA configurado, são gerados segmentos locais distribuídos pelo vídeo; o modo manual permite definir início e fim exactos. Abrir a página não inicia download, análise ou processamento.
+
 ## Criação de Vídeos — IA editorial e pacotes criativos
 
 O formulário permite escrever manualmente o **Tópico ou briefing** ou clicar em **Gerar tópico/briefing com IA**. O botão usa o provider LLM, Base URL, API key e modelo guardados em **Configurações Técnicas > API Keys**, incorpora a descrição, o nicho e o Blueprint do canal e coloca o resultado no campo para revisão. Abrir a página não inicia chamadas externas.

package/README.md

@@ -19,7 +19,7 @@ A primeira versão implementa a camada UI independente com:
 | Automação | Menu expansível com a subaba **Automação Youtube**, onde ficam os vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON, horário diário HH:MM e worker local baseado no relógio do computador |
 | Models AI | Menu expansível com Personagens e Redes Sociais reservados para desenvolvimento futuro |
 | Niche Finder | Menu expansível com duas alternativas independentes: Niche Finder Kaggle e Niche Finder Apify, com parâmetros, execução e resultados separados |
-| Edição | Menu expansível abaixo de Automação com Limpador de Metadados funcional, Cortes reservado e Editor Python inspirado no PYEdit para vídeos e scripts locais |
+| Edição | Menu expansível abaixo de Automação com Limpador de Metadados, Clip Generator local em Cortes e Editor Python inspirado no PYEdit para vídeos e scripts locais |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo via sessão Frontend API com cookies/sessionInfo por conta e DELEGATED_SESSION_ID por canal, TikTok, Instagram e Facebook Pages no front end |
 | MCP | Catálogo local opcional de Short Video Maker, AutoVio, OpenMontage e OpenCut, com portas editáveis e activação |
 | Configurações Técnicas | Provedores LLM, OpenAI/NVIDIA NIM com API key, Base URL e selector de modelos, TTS/voz, preview de vozes, Suno, materiais, Whisper, FFmpeg, OAuth YouTube, contas Google/YouTube para canais em lote com e-mail, Client ID, Client Secret e sessionInfo por conta, cartões expansíveis por nome/e-mail, documento credentials.json criado automaticamente e eliminação individual, cookies SID/SSID/HSID/APISID/SAPISID no documento JSON, Data API Key opcional, Kaggle Username/API Key, Apify API Token/Actor ID/limites, Upload directo, TikTok Client ID/Secret e Upload-Post |
@@ -38,7 +38,7 @@ 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.53
+## Navegação da UI 0.2.54
 
 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.
 
@@ -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.50 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.50 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.50
+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
 ```
 
 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.50 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.54 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Editor Python baseado no PYEdit
 
@@ -240,6 +240,14 @@ A aba **Limpador de Metadados** foi adaptada do workflow `YTBMetadataGenerator.j
 
 A descrição segue a composição do workflow de referência: preview, secção de links e capítulos/timestamps. O resultado inclui um manifesto JSON para utilizar os metadados num fluxo posterior de upload. A versão local não usa o trigger RSS, o Apify ou a actualização automática de um vídeo YouTube; em vez disso, o utilizador fornece directamente o vídeo terceiro e controla a edição antes de publicar.
 
+## Cortes — Clip Generator local
+
+A aba **Cortes** é um Clip Generator local inspirado no fluxo do [OpenShorts](https://github.com/mutonby/openshorts). Permite fazer upload de um vídeo, descarregar uma URL directa de vídeo, seleccionar um vídeo gerado pela pipeline ou escolher uma pasta local. O original é preservado em `storage/cuts/inputs/`.
+
+O formulário apresenta os formatos **9:16 — Shorts/Reels/TikTok**, **1:1 — Feed posts** e **16:9 — YouTube/landscape**, além de opções avançadas para modo automático por segmentos locais ou corte manual, número de clips, durações mínima/máxima e intervalo de início/fim. A execução só começa depois da confirmação explícita de direitos e do clique em **Gerar Clips**.
+
+Os clips são gerados localmente com FFmpeg, redimensionados para o formato escolhido sem ampliar desnecessariamente a fonte e guardados em `storage/cuts/runs/<id>/`. A página apresenta estado de análise, preview dos resultados, download individual, download ZIP, manifesto JSON e histórico em `storage/state/cuts_runs.json`. A selecção automática de momentos virais por IA permanece um ponto de extensão: sem transcrição/provider configurado, o modo manual continua disponível e não são inventados resultados.
+
 ## Canais YouTube
 
 A aba **Canais Youtube** está dividida em dois fluxos independentes. Em **Importar do YouTube**, o método padrão **Página pública — sem API Key** consulta a página pública do canal e preenche nome, ID, handle, URL, descrição e thumbnail quando esses dados estão disponíveis. A opção **YouTube Data API — API Key opcional** pode ser escolhida para métricas oficiais quando uma **YouTube Data API Key própria** estiver configurada em **Configurações** ou em `YOUTUBE_API_KEY`; essa chave é distinta do OAuth Client ID e Client Secret.

package/app/main.py

@@ -30,6 +30,7 @@ from app.modules.niche_finder.summarizer import summarize_items
 from hermes_ui.blueprints import create_blueprint_from_link, list_branding_files, save_generated_blueprint
 from hermes_ui.metadata_cleaner import build_description, clean_video_metadata, list_edit_records, metadata_manifest, normalize_tags, save_edit_record, store_external_video
 from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEditorError, change_speed, editor_manifest, extract_audio, list_edit_records as list_python_editor_records, list_generated_videos, list_scripts, list_video_files, read_script, remove_audio, replace_audio, resize_video, save_edit_record as save_python_editor_record, save_script, store_uploaded_asset, trim_video
+from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips, list_generated_videos as list_cut_generated_videos, list_runs as list_cut_runs, list_video_files as list_cut_video_files, manifest_bytes as cut_manifest_bytes, store_uploaded_video, zip_run as zip_cut_run
 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
@@ -150,7 +151,16 @@ st.markdown("""
 .content-label { color:#8ba6bb; font-size:.8rem; text-transform:uppercase; letter-spacing:.07em; }
 .content-value { color:#f4f8fb; font-size:1.8rem; font-weight:700; margin-top:.3rem; }
 .stage { border-left:3px solid #35a7ff; padding:.65rem .8rem; margin:.4rem 0; background:#101d2a; border-radius:8px; }
-.small-muted { color:#8ba6bb; font-size:.85rem; }
+ .small-muted { color:#8ba6bb; font-size:.85rem; }
+.tb-cuts-hero { max-width:860px; margin:0 auto 1.1rem; padding:1.6rem 1.4rem 1.35rem; text-align:center; border:1px solid #263d50; border-radius:18px; background:radial-gradient(circle at 50% 0, rgba(164,126,55,.16), transparent 58%), linear-gradient(145deg, rgba(17,27,37,.98), rgba(9,15,22,.98)); box-shadow:0 18px 48px rgba(0,0,0,.18); }
+.tb-cuts-hero .tb-cuts-kicker { color:#c59b55; font-size:.68rem; letter-spacing:.18em; text-transform:uppercase; font-weight:700; }
+.tb-cuts-hero h2 { color:#f5f0e8; font-family:Georgia,serif; font-size:2rem; font-weight:500; margin:.42rem 0 .25rem; text-transform:lowercase; }
+.tb-cuts-hero p { color:#9cafbf; margin:0 auto; max-width:620px; font-size:.9rem; }
+[data-testid="stRadio"] [role="radiogroup"] { gap:.6rem; }
+[data-testid="stRadio"] label { border:1px solid #2a4052; border-radius:12px; padding:.65rem .8rem; background:#101b25; min-height:4.3rem; }
+[data-testid="stRadio"] label:has(input:checked) { border-color:#c59b55; background:linear-gradient(145deg, rgba(96,71,33,.42), rgba(17,27,37,.95)); }
+[data-testid="stStatusWidget"] { border-color:#2a4052 !important; background:#101b25 !important; }
+
 /* Cores dos chips por identidade da plataforma, sem depender da ordem de selecção. */
 [data-testid="stMultiSelectTagsContainer"] span[data-tag] { color:#ffffff !important; border:0 !important; font-weight:700 !important; }
 [data-testid="stMultiSelectTagsContainer"] span[data-tag] span[title],
@@ -1485,6 +1495,189 @@ def render_edit_placeholder(page_title: str, description: str):
     st.info("Esta aba está reservada para desenvolvimento futuro e ainda não executa nenhuma operação.")
 
 
+def render_cuts():
+    st.title("Cortes")
+    st.caption("Crie clips verticais, quadrados ou horizontais a partir de vídeos longos, com um fluxo local inspirado no Clip Generator do OpenShorts.")
+
+    st.markdown(
+        "<div class='tb-cuts-hero'><div class='tb-cuts-kicker'>01 · CLIP GENERATOR</div><h2>Create Viral Shorts</h2><p>Escolha um vídeo longo, defina o formato e gere clips locais sem sobrescrever a fonte.</p></div>",
+        unsafe_allow_html=True,
+    )
+
+    source_path = None
+    source_tab, url_tab, generated_tab, folder_tab = st.tabs(["Upload ficheiro", "URL de vídeo", "Vídeos gerados", "Pasta local"])
+    with source_tab:
+        uploaded_video = st.file_uploader(
+            "Clique para carregar ou arraste um vídeo",
+            type=sorted(extension.lstrip(".") for extension in VIDEO_EXTENSIONS),
+            key="cuts_video_upload",
+            help="MP4, MOV, MKV, WEBM e formatos suportados pelo FFmpeg. O original fica preservado.",
+        )
+        if uploaded_video is not None:
+            try:
+                source_path = store_uploaded_video(uploaded_video.name, uploaded_video.getvalue())
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Upload · {uploaded_video.name}"
+            except CutsError as exc:
+                st.error(str(exc))
+    with url_tab:
+        url_value = st.text_input("URL directa do vídeo", placeholder="https://exemplo.com/video.mp4", key="cuts_video_url")
+        st.caption("A URL deve apontar directamente para um ficheiro de vídeo HTTP/HTTPS. O download só ocorre depois de clicar no botão.")
+        if st.button("Descarregar vídeo", key="cuts_download_url", use_container_width=True):
+            try:
+                source_path = download_direct_video_url(url_value)
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"URL · {url_value}"
+                st.success("Vídeo descarregado e pronto para análise.")
+            except CutsError as exc:
+                st.error(str(exc))
+    with generated_tab:
+        generated_paths = list_cut_generated_videos(read_json("tasks.json", []))
+        if not generated_paths:
+            st.info("Ainda não existem vídeos gerados com caminho registado na pipeline.")
+        else:
+            generated_labels = [f"{path.name} — {path}" for path in generated_paths]
+            selected_generated = st.selectbox("Vídeo gerado", range(len(generated_paths)), format_func=lambda index: generated_labels[index], key="cuts_generated_index")
+            if st.button("Usar vídeo seleccionado", key="cuts_use_generated", use_container_width=True):
+                source_path = generated_paths[selected_generated]
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Pipeline · {source_path.name}"
+    with folder_tab:
+        folder_value = st.text_input("Pasta de vídeos", value=str(STORAGE / "videos"), key="cuts_video_folder")
+        folder_paths = list_cut_video_files(folder_value)
+        if not folder_paths:
+            st.info("Não foram encontrados vídeos nessa pasta.")
+        else:
+            folder_labels = [f"{path.name} — {path}" for path in folder_paths]
+            selected_folder = st.selectbox("Vídeo da pasta", range(len(folder_paths)), format_func=lambda index: folder_labels[index], key="cuts_folder_index")
+            if st.button("Usar vídeo da pasta", key="cuts_use_folder", use_container_width=True):
+                source_path = folder_paths[selected_folder]
+                st.session_state["cuts_source_path"] = str(source_path)
+                st.session_state["cuts_source_label"] = f"Pasta local · {source_path.name}"
+
+    stored_source = st.session_state.get("cuts_source_path", "")
+    if not source_path and stored_source:
+        candidate = Path(stored_source)
+        if candidate.is_file():
+            source_path = candidate
+    if source_path and source_path.is_file():
+        st.markdown(f"**Fonte seleccionada:** `{st.session_state.get('cuts_source_label', source_path.name)}`")
+        source_cols = st.columns([1.4, 1])
+        with source_cols[0]:
+            st.video(str(source_path))
+        with source_cols[1]:
+            st.caption(f"{source_path.name}")
+            st.caption(f"{source_path.stat().st_size / (1024 * 1024):.2f} MB")
+            st.caption("A fonte original não é alterada.")
+    else:
+        st.info("Escolha um ficheiro, descarregue uma URL, seleccione um vídeo gerado ou indique uma pasta local.")
+
+    with st.container(border=True):
+        st.markdown("**Output format**")
+        format_options = ["9:16", "1:1", "16:9"]
+        output_format = st.radio(
+            "Formato de saída",
+            format_options,
+            format_func=lambda value: {"9:16": "9:16\\nShorts · Reels · TikTok", "1:1": "1:1\\nFeed posts", "16:9": "16:9\\nYouTube · landscape"}[value],
+            horizontal=True,
+            key="cuts_output_format",
+            label_visibility="collapsed",
+        )
+        with st.expander("advanced options", expanded=False):
+            strategy_label = st.selectbox("Estratégia", ["Automático · segmentos locais", "Manual · um intervalo"], key="cuts_strategy")
+            strategy = "manual" if strategy_label.startswith("Manual") else "automatic"
+            options_cols = st.columns(3)
+            with options_cols[0]:
+                max_clips = st.number_input("Número máximo de clips", min_value=1, max_value=20, value=3, step=1, key="cuts_max_clips")
+            with options_cols[1]:
+                min_duration = st.number_input("Duração mínima (s)", min_value=1.0, max_value=600.0, value=15.0, step=1.0, key="cuts_min_duration")
+            with options_cols[2]:
+                max_duration = st.number_input("Duração máxima (s)", min_value=1.0, max_value=600.0, value=60.0, step=1.0, key="cuts_max_duration")
+            manual_start = manual_end = 0.0
+            if strategy == "manual":
+                manual_cols = st.columns(2)
+                with manual_cols[0]:
+                    manual_start = st.number_input("Início do intervalo (s)", min_value=0.0, value=0.0, step=0.5, key="cuts_manual_start")
+                with manual_cols[1]:
+                    manual_end = st.number_input("Fim do intervalo (s)", min_value=0.5, value=30.0, step=0.5, key="cuts_manual_end")
+            st.caption("O modo automático cria segmentos locais distribuídos pelo vídeo. A selecção viral por IA fica disponível como extensão quando houver transcrição/provider configurado.")
+
+        rights_confirmed = st.checkbox(
+            "Confirmo que possuo os direitos ou autorização para processar este conteúdo.",
+            key="cuts_rights_confirmed",
+        )
+        generate_button = st.button(
+            "Gerar Clips",
+            type="primary",
+            use_container_width=True,
+            disabled=not (source_path and source_path.is_file() and rights_confirmed),
+            key="cuts_generate_button",
+        )
+
+    if generate_button and source_path and source_path.is_file():
+        settings = read_json("settings.json", {})
+        with st.status("A analisar e a gerar clips…", expanded=True) as status:
+            st.write("A validar fonte e parâmetros…")
+            try:
+                record = generate_clips(
+                    source_path,
+                    output_format=output_format,
+                    strategy=strategy,
+                    max_clips=int(max_clips),
+                    min_duration=float(min_duration),
+                    max_duration=float(max_duration),
+                    rights_confirmed=rights_confirmed,
+                    ffmpeg_path=settings.get("ffmpeg_path", ""),
+                    manual_start=float(manual_start),
+                    manual_end=float(manual_end) if strategy == "manual" else None,
+                )
+                st.session_state["cuts_last_run"] = record
+                status.update(label="Clips gerados", state="complete", expanded=False)
+            except CutsError as exc:
+                status.update(label="A geração falhou", state="error", expanded=True)
+                st.error(str(exc))
+
+    last_run = st.session_state.get("cuts_last_run")
+    if last_run:
+        st.divider()
+        status_label = {"complete": "CONCLUÍDO", "processing": "A PROCESSAR", "error": "ERRO"}.get(last_run.get("status"), str(last_run.get("status", "—")).upper())
+        st.markdown(f"### Live Analysis · `{status_label}`")
+        if last_run.get("status") == "complete":
+            clips = [clip for clip in last_run.get("clips", []) if Path(str(clip.get("path", ""))).is_file()]
+            result_cols = st.columns([3, 1, 1])
+            with result_cols[0]:
+                st.subheader("Generated Shorts")
+            with result_cols[1]:
+                st.metric("Clips", len(clips))
+            with result_cols[2]:
+                st.metric("Formato", last_run.get("output_format", "—"))
+            for index in range(0, len(clips), 3):
+                clip_cols = st.columns(3)
+                for col, clip in zip(clip_cols, clips[index:index + 3]):
+                    with col:
+                        with st.container(border=True):
+                            st.caption(f"Clip {clip.get('index', '—')} · {float(clip.get('duration', 0)):.1f}s")
+                            st.video(str(clip["path"]))
+                            st.download_button("Descarregar clip", data=Path(clip["path"]).read_bytes(), file_name=clip["name"], mime="video/mp4", key=f"cuts_download_{last_run['id']}_{clip['index']}", use_container_width=True)
+            try:
+                _, archive_bytes = zip_cut_run(last_run)
+                st.download_button("Descarregar todos os clips (ZIP)", data=archive_bytes, file_name=f"{last_run['id']}.zip", mime="application/zip", key=f"cuts_download_zip_{last_run['id']}", use_container_width=True)
+            except CutsError as exc:
+                st.warning(str(exc))
+            st.download_button("Descarregar manifesto JSON", data=cut_manifest_bytes(last_run), file_name=f"{last_run['id']}.json", mime="application/json", key=f"cuts_download_manifest_{last_run['id']}", use_container_width=True)
+        elif last_run.get("error"):
+            st.error(last_run["error"])
+
+    runs = list_cut_runs()
+    if runs:
+        with st.expander("Histórico do Clip Generator"):
+            st.dataframe(
+                [{"Data": run.get("created_at", "—"), "Fonte": run.get("source_name", "—"), "Formato": run.get("output_format", "—"), "Clips": len(run.get("clips", [])), "Estado": run.get("status", "—")} for run in runs[:20]],
+                use_container_width=True,
+                hide_index=True,
+            )
+
+
 def render_python_editor():
     st.title("Editor Python")
     st.caption("Editor local inspirado no PYEdit para scripts Python e edição manual de vídeos do Thunderbolt.")
@@ -2686,7 +2879,7 @@ def main():
         "Niche Finder Apify": render_niche_finder_apify,
         "Edição": lambda: render_edit_placeholder("Edição", "Seleccione uma das abas de edição no menu expansível."),
         "Limpador de Metadados": render_metadata_cleaner,
-        "Cortes": lambda: render_edit_placeholder("Cortes", "Área reservada para a futura funcionalidade de cortes de vídeo."),
+        "Cortes": render_cuts,
         "Editor Python": render_python_editor,
         "Models AI": lambda: render_edit_placeholder("Models AI", "Seleccione uma das abas Models AI no menu expansível."),
         "Personagens": lambda: render_edit_placeholder("Personagens", "Área reservada para a futura funcionalidade de personagens."),

package/hermes_ui/cuts.py

@@ -0,0 +1,454 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+import unicodedata
+import uuid
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+from urllib.parse import urlparse
+
+import requests
+
+from . import storage
+from .metadata_cleaner import VIDEO_EXTENSIONS, _resolve_ffmpeg
+
+
+class CutsError(RuntimeError):
+    """Raised when a local clip-generation operation cannot be completed."""
+
+
+OUTPUT_FORMATS: dict[str, dict[str, Any]] = {
+    "9:16": {"width": 1080, "height": 1920, "label": "9:16 · Shorts / Reels / TikTok"},
+    "1:1": {"width": 1080, "height": 1080, "label": "1:1 · Feed posts"},
+    "16:9": {"width": 1920, "height": 1080, "label": "16:9 · YouTube / landscape"},
+}
+
+VIDEO_SUFFIXES = {f".{extension.lower().lstrip('.')}" for extension in VIDEO_EXTENSIONS}
+MAX_SOURCE_BYTES = 500 * 1024 * 1024
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _root() -> Path:
+    path = storage.STORAGE / "cuts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _inputs() -> Path:
+    path = _root() / "inputs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _runs_root() -> Path:
+    path = _root() / "runs"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _safe_filename(name: str, fallback: str = "video") -> str:
+    normalized = unicodedata.normalize("NFKD", Path(name).name)
+    ascii_name = normalized.encode("ascii", "ignore").decode("ascii")
+    safe = re.sub(r"[^A-Za-z0-9._-]+", "-", ascii_name).strip(".-")
+    return safe or fallback
+
+
+def _validate_video(source: Path) -> Path:
+    candidate = Path(source).expanduser()
+    if not candidate.is_file():
+        raise CutsError("O vídeo seleccionado não existe ou não é um ficheiro.")
+    if candidate.suffix.lower() not in VIDEO_SUFFIXES:
+        raise CutsError("O vídeo seleccionado não tem uma extensão suportada.")
+    return candidate.resolve()
+
+
+def _safe_float(value: Any, fallback: float = 0.0) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return fallback
+
+
+def normalize_output_format(output_format: str) -> str:
+    key = str(output_format or "").strip()
+    if key not in OUTPUT_FORMATS:
+        raise CutsError("Seleccione um formato de saída válido: 9:16, 1:1 ou 16:9.")
+    return key
+
+
+def store_uploaded_video(filename: str, content: bytes) -> Path:
+    if not content:
+        raise CutsError("O ficheiro de vídeo está vazio.")
+    suffix = Path(filename).suffix.lower()
+    if suffix not in VIDEO_SUFFIXES:
+        raise CutsError("O ficheiro enviado não tem uma extensão de vídeo suportada.")
+    digest = hashlib.sha256(content).hexdigest()[:16]
+    existing = next(iter(sorted(_inputs().glob(f"{digest}-*"))), None)
+    if existing and existing.is_file():
+        return existing.resolve()
+    target = _inputs() / f"{digest}-{_safe_filename(filename, 'video')}"
+    if not target.exists():
+        target.write_bytes(content)
+    return target.resolve()
+
+
+def list_video_files(folder: str | Path) -> list[Path]:
+    candidate = Path(folder).expanduser()
+    if not candidate.exists():
+        return []
+    if candidate.is_file():
+        return [candidate.resolve()] if candidate.suffix.lower() in VIDEO_SUFFIXES else []
+    try:
+        return sorted(
+            (path.resolve() for path in candidate.iterdir() if path.is_file() and path.suffix.lower() in VIDEO_SUFFIXES),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+    except OSError as exc:
+        raise CutsError(f"Não foi possível ler a pasta de vídeos: {exc}") from exc
+
+
+def list_generated_videos(tasks: Iterable[dict[str, Any]]) -> list[Path]:
+    paths: dict[str, Path] = {}
+    for task in tasks:
+        artifacts = task.get("artifacts") or {}
+        value = artifacts.get("video")
+        if isinstance(value, str) and value.strip():
+            candidate = Path(value).expanduser()
+            if candidate.is_file() and candidate.suffix.lower() in VIDEO_SUFFIXES:
+                paths[str(candidate.resolve())] = candidate.resolve()
+    return sorted(paths.values(), key=lambda path: path.stat().st_mtime, reverse=True)
+
+
+def resolve_ffmpeg(configured_path: str | None = None) -> str:
+    try:
+        return _resolve_ffmpeg(configured_path)
+    except RuntimeError as exc:
+        raise CutsError(str(exc)) from exc
+
+
+def resolve_ffprobe(configured_path: str | None = None) -> str | None:
+    configured = str(configured_path or "").strip()
+    candidates: list[str] = []
+    if configured:
+        configured_path_obj = Path(configured).expanduser()
+        if configured_path_obj.name.lower().startswith("ffmpeg"):
+            candidates.append(str(configured_path_obj.with_name("ffprobe" + configured_path_obj.suffix)))
+        candidates.append(configured)
+    detected = shutil.which("ffprobe")
+    if detected:
+        candidates.append(detected)
+    for candidate in candidates:
+        resolved = shutil.which(candidate) or (candidate if Path(candidate).is_file() else None)
+        if resolved:
+            return str(resolved)
+    return None
+
+
+def probe_duration(source: Path, *, ffprobe_path: str | None = None) -> float | None:
+    source = _validate_video(source)
+    binary = resolve_ffprobe(ffprobe_path)
+    if not binary:
+        return None
+    command = [binary, "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", str(source)]
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError:
+        return None
+    if completed.returncode != 0:
+        return None
+    duration = _safe_float(completed.stdout.strip(), 0.0)
+    return duration if duration > 0 else None
+
+
+def validate_cut_request(
+    *,
+    source: Path,
+    output_format: str,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    rights_confirmed: bool,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> dict[str, Any]:
+    source = _validate_video(source)
+    output_format = normalize_output_format(output_format)
+    if strategy not in {"automatic", "manual"}:
+        raise CutsError("Seleccione uma estratégia de corte válida.")
+    if not rights_confirmed:
+        raise CutsError("Confirme que possui os direitos ou autorização para processar este conteúdo.")
+    max_clips = int(max_clips)
+    if max_clips < 1 or max_clips > 20:
+        raise CutsError("A quantidade de clips deve estar entre 1 e 20.")
+    min_duration = _safe_float(min_duration)
+    max_duration = _safe_float(max_duration)
+    if min_duration < 1 or max_duration > 600 or max_duration < min_duration:
+        raise CutsError("Defina uma duração válida: mínimo ≥ 1s, máximo ≤ 600s e máximo ≥ mínimo.")
+    manual_start = _safe_float(manual_start)
+    if manual_start < 0:
+        raise CutsError("O início manual não pode ser negativo.")
+    normalized_end = None if manual_end is None else _safe_float(manual_end)
+    if strategy == "manual" and (normalized_end is None or normalized_end <= manual_start):
+        raise CutsError("No modo manual, o fim deve ser superior ao início.")
+    return {
+        "source": str(source),
+        "source_name": source.name,
+        "output_format": output_format,
+        "strategy": strategy,
+        "max_clips": max_clips,
+        "min_duration": min_duration,
+        "max_duration": max_duration,
+        "manual_start": manual_start,
+        "manual_end": normalized_end,
+        "rights_confirmed": True,
+    }
+
+
+def plan_segments(
+    duration: float | None,
+    *,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> list[dict[str, float]]:
+    if strategy == "manual":
+        if manual_end is None or manual_end <= manual_start:
+            raise CutsError("No modo manual, o fim deve ser superior ao início.")
+        return [{"index": 1, "start": round(float(manual_start), 3), "end": round(float(manual_end), 3), "duration": round(float(manual_end - manual_start), 3)}]
+    if duration is None or duration <= 0:
+        raise CutsError("Não foi possível detectar a duração do vídeo. Use o modo manual ou instale/configure FFprobe.")
+    if duration < min_duration:
+        raise CutsError(f"O vídeo tem apenas {duration:.1f}s e é menor que a duração mínima configurada.")
+    count = min(int(max_clips), max(1, int(duration // min_duration)))
+    clip_duration = min(float(max_duration), max(float(min_duration), duration / count))
+    if clip_duration > duration:
+        clip_duration = duration
+    if count == 1:
+        starts = [0.0]
+    else:
+        starts = [(duration - clip_duration) * index / (count - 1) for index in range(count)]
+    return [
+        {"index": index + 1, "start": round(start, 3), "end": round(min(duration, start + clip_duration), 3), "duration": round(min(duration, start + clip_duration) - start, 3)}
+        for index, start in enumerate(starts)
+    ]
+
+
+def _video_filter(output_format: str) -> str:
+    dimensions = OUTPUT_FORMATS[normalize_output_format(output_format)]
+    width = dimensions["width"]
+    height = dimensions["height"]
+    return f"scale={width}:{height}:force_original_aspect_ratio=decrease,pad={width}:{height}:(ow-iw)/2:(oh-ih)/2"
+
+
+def build_clip_command(source: Path, output: Path, segment: dict[str, float], output_format: str, *, ffmpeg_path: str) -> list[str]:
+    start = max(0.0, float(segment["start"]))
+    duration = max(0.1, float(segment["duration"]))
+    return [
+        ffmpeg_path,
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-ss",
+        f"{start:.3f}",
+        "-t",
+        f"{duration:.3f}",
+        "-i",
+        str(source),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a?",
+        "-vf",
+        _video_filter(output_format),
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "22",
+        "-c:a",
+        "aac",
+        "-movflags",
+        "+faststart",
+        str(output),
+    ]
+
+
+def _run_ffmpeg(command: list[str], output: Path, *, source: Path, segment: dict[str, float]) -> dict[str, Any]:
+    try:
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+    except OSError as exc:
+        raise CutsError(f"Não foi possível iniciar FFmpeg: {exc}") from exc
+    if completed.returncode != 0 or not output.is_file() or output.stat().st_size == 0:
+        if output.exists():
+            output.unlink()
+        detail = (completed.stderr or completed.stdout or "erro desconhecido").strip()
+        raise CutsError(f"O clip não pôde ser gerado: {detail[-1200:]}")
+    return {"source": str(source), "output": str(output), "command": command, "segment": segment, "created_at": _now()}
+
+
+def _write_manifest(record: dict[str, Any], run_dir: Path) -> Path:
+    path = run_dir / "manifest.json"
+    path.write_text(json.dumps(record, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def generate_clips(
+    source: Path,
+    *,
+    output_format: str,
+    strategy: str,
+    max_clips: int,
+    min_duration: float,
+    max_duration: float,
+    rights_confirmed: bool,
+    ffmpeg_path: str | None = None,
+    manual_start: float = 0.0,
+    manual_end: float | None = None,
+) -> dict[str, Any]:
+    request = validate_cut_request(
+        source=source,
+        output_format=output_format,
+        strategy=strategy,
+        max_clips=max_clips,
+        min_duration=min_duration,
+        max_duration=max_duration,
+        rights_confirmed=rights_confirmed,
+        manual_start=manual_start,
+        manual_end=manual_end,
+    )
+    duration = probe_duration(source)
+    segments = plan_segments(
+        duration,
+        strategy=strategy,
+        max_clips=max_clips,
+        min_duration=min_duration,
+        max_duration=max_duration,
+        manual_start=manual_start,
+        manual_end=manual_end,
+    )
+    run_id = f"cut_{datetime.now().strftime('%Y%m%d-%H%M%S')}_{uuid.uuid4().hex[:8]}"
+    run_dir = _runs_root() / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+    record: dict[str, Any] = {
+        "id": run_id,
+        "created_at": _now(),
+        "status": "processing",
+        "source": request["source"],
+        "source_name": request["source_name"],
+        "source_duration": duration,
+        "output_format": output_format,
+        "strategy": strategy,
+        "parameters": {key: value for key, value in request.items() if key not in {"source", "source_name"}},
+        "clips": [],
+        "error": "",
+    }
+    try:
+        binary = resolve_ffmpeg(ffmpeg_path)
+        for segment in segments:
+            output = run_dir / f"clip-{int(segment['index']):02d}-{_safe_filename(source.stem, 'video')}-{output_format.replace(':', 'x')}.mp4"
+            command = build_clip_command(source, output, segment, output_format, ffmpeg_path=binary)
+            run_info = _run_ffmpeg(command, output, source=source, segment=segment)
+            record["clips"].append({
+                "index": int(segment["index"]),
+                "path": str(output),
+                "name": output.name,
+                "start": segment["start"],
+                "end": segment["end"],
+                "duration": segment["duration"],
+                "size_bytes": output.stat().st_size,
+                "command": run_info["command"],
+            })
+        record["status"] = "complete"
+    except (CutsError, OSError, ValueError) as exc:
+        record["status"] = "error"
+        record["error"] = str(exc)
+    _write_manifest(record, run_dir)
+    storage.append_json("cuts_runs.json", record)
+    if record["status"] == "error":
+        raise CutsError(record["error"])
+    return record
+
+
+def list_runs() -> list[dict[str, Any]]:
+    records = storage.read_json("cuts_runs.json", [])
+    return list(reversed(records)) if isinstance(records, list) else []
+
+
+def manifest_bytes(record: dict[str, Any]) -> bytes:
+    return (json.dumps(record, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def zip_run(record: dict[str, Any]) -> tuple[Path, bytes]:
+    run_id = _safe_filename(str(record.get("id") or "run"), "run")
+    run_dir = _runs_root() / run_id
+    if not run_dir.is_dir():
+        raise CutsError("A execução seleccionada já não existe no storage local.")
+    archive = run_dir / f"{run_id}.zip"
+    with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as handle:
+        for clip in record.get("clips", []):
+            path = Path(str(clip.get("path") or ""))
+            if path.is_file() and run_dir.resolve() in path.resolve().parents:
+                handle.write(path, arcname=path.name)
+        manifest = run_dir / "manifest.json"
+        if manifest.is_file():
+            handle.write(manifest, arcname=manifest.name)
+    return archive, archive.read_bytes()
+
+
+def download_direct_video_url(url: str, *, timeout: int = 30) -> Path:
+    parsed = urlparse(str(url).strip())
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise CutsError("Informe uma URL HTTP/HTTPS directa para um ficheiro de vídeo.")
+    try:
+        response = requests.get(url, stream=True, timeout=timeout, headers={"User-Agent": "Thunderbolt/0.2"})
+        response.raise_for_status()
+    except requests.RequestException as exc:
+        raise CutsError(f"Não foi possível descarregar a URL do vídeo: {exc}") from exc
+    content_length = _safe_float(response.headers.get("content-length"), 0.0)
+    if content_length > MAX_SOURCE_BYTES:
+        raise CutsError("A fonte excede o limite de 500 MB.")
+    suffix = Path(parsed.path).suffix.lower()
+    if suffix not in VIDEO_SUFFIXES:
+        content_type = str(response.headers.get("content-type") or "").lower()
+        suffix = ".mp4" if "mp4" in content_type or "video" in content_type else ""
+    if suffix not in VIDEO_SUFFIXES:
+        raise CutsError("A URL deve apontar para um ficheiro de vídeo MP4, MOV ou formato suportado.")
+    digest = hashlib.sha256(url.encode("utf-8")).hexdigest()[:16]
+    target = _inputs() / f"{digest}-url{suffix}"
+    if target.exists():
+        return target.resolve()
+    total = 0
+    temporary = target.with_suffix(target.suffix + ".part")
+    try:
+        with temporary.open("wb") as handle:
+            for chunk in response.iter_content(chunk_size=1024 * 1024):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > MAX_SOURCE_BYTES:
+                    raise CutsError("A fonte excede o limite de 500 MB.")
+                handle.write(chunk)
+        temporary.replace(target)
+    except CutsError:
+        temporary.unlink(missing_ok=True)
+        raise
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise CutsError(f"Não foi possível guardar o vídeo descarregado: {exc}") from exc
+    return target.resolve()

package/package.json

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