@danhachuel/thunderbolt 0.2.29 → 0.2.30

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.29
+> **Versão deste manual:** 0.2.30
 > **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.29 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.30 install
 ```
 
 Linux/macOS:
 
 ```bash
-npx --yes @danhachuel/thunderbolt@0.2.29 install
+npx --yes @danhachuel/thunderbolt@0.2.30 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.
@@ -362,7 +362,7 @@ Após iniciar a aplicação, valide o seguinte percurso:
 2. **Blueprints:** coloque um JSON em `~/.thunderbolt/storage/blueprints/importados/` (Windows: `%LOCALAPPDATA%\\THUNDERBOLT\storage\blueprints\importados\`) ou use o carregador da interface.
 3. **Brandings:** abra a subaba **Brandings** e confirme a listagem dos ficheiros JSON.
 4. **Canais:** em **Importar do YouTube**, use o método **Página pública — sem API Key** com um URL `/channel/UC...`, um handle ou uma subpágina `/videos`; o parser resolve o ID, consulta a página pública e tenta o RSS quando necessário. Confirme que o resultado abre o formulário de revisão sem Data API Key. Se o canal não existir ou não fornecer metadados, confirme a mensagem clara e que o formulário de uma pesquisa anterior desaparece. A Data API é opcional e fica separada; em **Cadastro manual**, preencha os dados sem qualquer consulta externa.
-5. **Niche Finder:** abra a página na sidebar, clique em **Baixar Dataset Kaggle** ou carregue um CSV próprio e confirme o ficheiro em `storage/data/niches/`. Com um CSV que contenha `title`, `publish_date`, `country`, `view_count`, `like_count` e `comment_count`, clique em **Usar CSV carregado**, escolha 3 clusters e suporte 0,05 e execute **Analisar Nichos**. Confirme as métricas, a tabela de clusters, o gráfico Plotly, as regras de associação e os dados filtrados. Altere país, engagement, datas e tags e confirme que a análise é recalculada.
+5. **Niche Finder:** abra a página na sidebar e aguarde a preparação automática. Confirme que não aparece upload de CSV, botão de download de dataset ou selector de ficheiros. A análise inicial deve carregar directamente métricas, clusters, gráfico Plotly, regras de associação e dados analisados. Altere país, engagement, datas e tags e confirme que **Analisar Nichos** recalcula os resultados.
 6. **Pipeline > Criação de Vídeos:** teste primeiro o modo **Canal específico** e depois os modos de lote.
 7. **Criação de Vídeos > Vídeos:** verifique o estado `to_do` e os botões **Iniciar** e **Parar** dentro da subaba. Confirme também que **Criação de Músicas** mostra o mesmo fluxo com título próprio.
 8. **Upload:** configure o OAuth Client ID e Secret, autorize primeiro o **youtube-automation-agent** na própria aba, confirme o estado **pronto para publicar**, preencha título/descrição/tags e publique um MP4 real. O botão **Autorizar fallback OAuth** existe apenas para redundância; a Data API Key, se configurada, é exclusivamente para consultas oficiais públicas e nunca substitui OAuth.
@@ -380,11 +380,11 @@ Após iniciar a aplicação, valide o seguinte percurso:
 
 A página **Niche Finder** integra a lógica adaptada do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder), cujo projecto original usa K-Means e FP-Growth sobre o dataset público [Trending Youtube Video Statistics (113 Countries)](https://www.kaggle.com/datasets/asaniczka/trending-youtube-videos-113-countries). No Thunderbolt não existe Flask, rota HTTP adicional, template HTML, JavaScript D3 ou segundo processo; toda a análise é síncrona no Streamlit.
 
-O botão **Baixar Dataset Kaggle** guarda a cópia em `storage/data/niches/`. O carregador usa KaggleHub para obter o dataset público; não existem credenciais hardcoded. Também é possível carregar um CSV próprio e clicar em **Usar CSV carregado**. O esquema mínimo é `title`, `publish_date`, `country`, `view_count`, `like_count` e `comment_count`; `video_tags` é opcional para obter itemsets e regras de associação. A cache utiliza `st.cache_data` para evitar leituras repetidas do mesmo ficheiro.
+Ao abrir a página, o Thunderbolt prepara automaticamente os dados públicos através do KaggleHub e inicia a análise. O utilizador não precisa de baixar datasets, carregar CSVs, preparar planilhas ou escolher ficheiros. A interface apresenta directamente os parâmetros da busca e os resultados.
 
-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. 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. Os resultados são DataFrames de clusters, itemsets frequentes, regras de associação e dados filtrados; o gráfico de dispersão é criado nativamente com Plotly. A cache de dados e os CSVs locais são ignorados pelo Git.
+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. 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. A análise inicial é automática; o botão **Analisar Nichos** recalcula os resultados depois de alterar os 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.29 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.30 install`; o instalador detecta e reutiliza o que já estiver válido.
 
 ## Pipeline: Criação de Vídeos, Criação de Músicas e Automação
 

package/README.md

@@ -17,7 +17,7 @@ A primeira versão implementa a camada UI independente com:
 | Canais | Subabas de importação pública sem API Key, Data API opcional e cadastro manual independente |
 | Criação de Vídeos / Criação de Músicas | Subabas Criar vídeo e Vídeos; lotes; 51 rótulos de idioma; Pexels/Pixabay, full IA com Estilo IA e Apenas Música com agente musical; a segunda página reutiliza o mesmo fluxo com título próprio |
 | Automação | Lista de vídeos e canais, selectores editáveis de Blueprint/voz padrão, Automação ON e horário diário HH:MM; UI configurável sem worker em segundo plano |
-| Niche Finder | Dataset Kaggle ou CSV próprio, cache local, filtros, K-Means, FP-Growth, regras de associação, clusters e gráfico Plotly nativo |
+| Niche Finder | Preparação e análise automáticas, filtros, K-Means, FP-Growth, regras de associação, clusters e gráfico Plotly nativo |
 | Upload | YouTube via `youtube-automation-agent` adaptado internamente, OAuth directo de redundância, Upload directo experimental, 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 |
 | Limpador de Metadados | Upload isolado de vídeos terceiros, limpeza FFmpeg, edição de título/descrição/tags e manifesto JSON |
@@ -26,7 +26,7 @@ A primeira versão implementa a camada UI independente com:
 
 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.29
+## Navegação da UI 0.2.30
 
 A barra lateral mantém apenas os cinco níveis principais, nesta ordem: **Início**, **Pipeline**, **Automação**, **Niche Finder** e **Configurações**. **Pipeline** é expansível e contém **Criação de Vídeos**, **Criação de Músicas**, **Upload** e **Limpador de Metadados**. **Configurações** é expansível e contém **Canais**, **Blueprints**, **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.
 
@@ -109,9 +109,9 @@ thunderbolt
 No Windows PowerShell, se `npx` for bloqueado por `npx.ps1`, use directamente `npx.cmd`:
 
 ```powershell
-npx.cmd --yes @danhachuel/thunderbolt@0.2.29 install
-npx.cmd --yes @danhachuel/thunderbolt@0.2.29 doctor
-npx.cmd --yes @danhachuel/thunderbolt@0.2.29
+npx.cmd --yes @danhachuel/thunderbolt@0.2.30 install
+npx.cmd --yes @danhachuel/thunderbolt@0.2.30 doctor
+npx.cmd --yes @danhachuel/thunderbolt@0.2.30
 ```
 
 Como alternativa, pode permitir scripts para o seu utilizador:
@@ -131,13 +131,11 @@ Após `install`, o launcher usa o ambiente virtual instalado em `~/.thunderbolt/
 
 ## Niche Finder
 
-A página **Niche Finder** integra a lógica do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder) directamente no processo Streamlit. O Thunderbolt não inicia Flask, não abre uma porta adicional e não copia templates HTML ou D3. A análise usa o dataset público [Trending Youtube Video Statistics (113 Countries)](https://www.kaggle.com/datasets/asaniczka/trending-youtube-videos-113-countries), mas também aceita um CSV próprio.
+A página **Niche Finder** integra a lógica do projecto open source [johanfortus/Niche-Finder](https://github.com/johanfortus/Niche-Finder) directamente no processo Streamlit. O Thunderbolt não inicia Flask, não abre uma porta adicional e não copia templates HTML ou D3. Ao abrir a página, o próprio Thunderbolt prepara automaticamente os dados públicos necessários através do KaggleHub, guarda a cache localmente e executa a análise; o utilizador não precisa de baixar datasets, carregar CSVs ou preparar planilhas.
 
-Na sidebar da página, use **Baixar Dataset Kaggle** para descarregar e guardar o dataset em `storage/data/niches/`, ou carregue um CSV e clique em **Usar CSV carregado**. A cache é mantida localmente e o carregador valida as colunas mínimas `title`, `publish_date`, `country`, `view_count`, `like_count` e `comment_count`. Não são necessárias credenciais Kaggle hardcoded: o KaggleHub obtém o dataset público e guarda o resultado na cache local.
+A interface apresenta directamente 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 análise inicial é executada automaticamente e **Analisar Nichos** permite recalcular os resultados depois de alterar os filtros. 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.
 
-O painel permite seleccionar 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. **Analisar Nichos** 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 filtrados, acompanhados por uma visualização Plotly nativa e pesquisa de palavras nos clusters. O download/cache dos dados é feito de forma lazy e os CSVs não são versionados pelo Git.
-
-As dependências adicionais são instaladas pelo fluxo normal do pacote: `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.29 install`; o instalador detecta e reutiliza componentes já válidos.
+As dependências adicionais são instaladas pelo fluxo normal do pacote: `scikit-learn`, `mlxtend`, `plotly`, `seaborn`, `matplotlib` e `kagglehub`. Em instalações existentes, execute novamente `npx.cmd --yes @danhachuel/thunderbolt@0.2.30 install`; o instalador detecta e reutiliza componentes já válidos.
 
 ## Armazenamento local
 
@@ -158,7 +156,7 @@ storage/
 ├── music/             # músicas locais para o modo Apenas Música
 ├── voice_previews/    # amostras isoladas do teste de vozes
 ├── data/
-│   └── niches/        # dataset Kaggle cacheado e CSVs enviados ao Niche Finder
+│   └── niches/        # dados automáticos cacheados para o Niche Finder
 ├── skills/            # skill MoneyPrinterTurbo guardada pelo utilizador
 ├── metadata_cleaner/
 │   ├── originals/    # cópias dos vídeos terceiros enviados

package/app/main.py

@@ -20,7 +20,7 @@ except (OSError, json.JSONDecodeError):
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, pipeline_summary, set_channel_defaults, transition_task, update_channel
 from hermes_ui.storage import BLUEPRINTS, ensure_storage, list_blueprint_files, load_blueprint_file, now, read_json, write_json
 from app.modules.niche_finder.core import NicheAnalysisError, run_niche_analysis
-from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset, list_cached_datasets, load_dataframe, save_uploaded_csv
+from app.modules.niche_finder.data_loader import DatasetError, download_kaggle_dataset, load_dataframe
 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.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
@@ -639,6 +639,12 @@ def _cached_niche_download():
     return str(download_kaggle_dataset())
 
 
+def _load_automatic_niche_dataset():
+    dataset_path = _cached_niche_download()
+    path = Path(dataset_path)
+    return dataset_path, _cached_niche_dataset(dataset_path, path.stat().st_mtime_ns)
+
+
 def _niche_tag_options(frame) -> list[str]:
     tags: set[str] = set()
     for value in frame.get("video_tags", []):
@@ -659,62 +665,28 @@ def _niche_date_bounds(frame):
 
 def render_niche_finder():
     st.title("Niche Finder")
-    st.caption("Busca de nichos baseada no projecto open source Niche-Finder, integrada no processo Streamlit do Thunderbolt.")
-    st.info("A análise é executada localmente, sem Flask ou segundo servidor. O dataset padrão é guardado em `storage/data/niches/` e pode ser substituído por um CSV próprio.")
-
-    with st.sidebar:
-        st.subheader("Fonte de dados")
-        uploaded_file = st.file_uploader("Carregar CSV próprio", type=["csv"], key="niche_uploaded_csv")
-        if st.button("Baixar Dataset Kaggle", use_container_width=True, key="niche_download_dataset"):
-            try:
-                downloaded = _cached_niche_download()
-                st.session_state["niche_dataset_path"] = downloaded
-                st.success("Dataset Kaggle guardado no storage local.")
-                st.rerun()
-            except DatasetError as exc:
-                st.error(str(exc))
-        cached = list_cached_datasets()
-        if cached:
-            labels = {str(path): path.relative_to(path.parents[2]).as_posix() if len(path.parents) > 2 else path.name for path in cached}
-            current_path = st.session_state.get("niche_dataset_path", str(cached[0]))
-            if current_path not in labels:
-                current_path = str(cached[0])
-            selected_path = st.selectbox("Dataset local", list(labels), index=list(labels).index(current_path), format_func=lambda item: labels[item], key="niche_dataset_selector")
-            if selected_path != st.session_state.get("niche_dataset_path"):
-                st.session_state["niche_dataset_path"] = selected_path
-                st.session_state.pop("niche_results", None)
-                st.rerun()
-        if uploaded_file is not None and st.button("Usar CSV carregado", use_container_width=True, key="niche_use_uploaded"):
-            try:
-                uploaded_path = save_uploaded_csv(uploaded_file.getvalue(), uploaded_file.name)
-                st.session_state["niche_dataset_path"] = str(uploaded_path)
-                st.session_state.pop("niche_results", None)
-                st.success(f"CSV guardado em `{uploaded_path}`.")
-                st.rerun()
-            except DatasetError as exc:
-                st.error(str(exc))
+    st.caption("Busca automática de padrões, nichos e tags para orientar canais faceless.")
+    st.info("O Thunderbolt prepara e analisa automaticamente os dados necessários. Não é necessária configuração manual.")
 
-    dataset_path = st.session_state.get("niche_dataset_path")
-    frame = None
-    if dataset_path:
-        path = Path(dataset_path)
-        if path.exists():
-            try:
-                frame = _cached_niche_dataset(str(path), path.stat().st_mtime_ns)
-            except (DatasetError, OSError) as exc:
-                st.error(str(exc))
-        else:
-            st.warning("O dataset seleccionado já não existe no storage local. Baixe-o novamente ou carregue um CSV.")
-    if frame is None:
-        st.subheader("Começar uma análise")
-        st.write("Baixe o dataset público do Kaggle ou carregue um CSV com as colunas `title`, `publish_date`, `country`, `view_count`, `like_count` e `comment_count`.")
+    try:
+        with st.spinner("A preparar automaticamente o Niche Finder…"):
+            dataset_path, frame = _load_automatic_niche_dataset()
+    except (DatasetError, OSError) as exc:
+        st.error("Não foi possível preparar automaticamente o Niche Finder neste momento. Verifique a ligação à Internet e tente novamente.")
+        with st.expander("Detalhes técnicos"):
+            st.caption(str(exc))
         return
 
+    signature = f"{dataset_path}:{Path(dataset_path).stat().st_mtime_ns}"
+    if st.session_state.get("niche_results_signature") != signature:
+        st.session_state.pop("niche_results", None)
+        st.session_state["niche_results_signature"] = signature
+
     min_date, max_date = _niche_date_bounds(frame)
     countries = ["Todos"] + sorted(str(value) for value in frame["country"].dropna().unique())
     tag_options = _niche_tag_options(frame)
     with st.sidebar:
-        st.subheader("Parâmetros")
+        st.subheader("Parâmetros da busca")
         n_clusters = st.slider("Número de Clusters", 2, 10, 5, key="niche_n_clusters")
         min_support = st.slider("Suporte Mínimo", 0.01, 0.5, 0.05, 0.01, format="%.2f", key="niche_min_support")
         country = st.selectbox("País", countries, key="niche_country")
@@ -724,11 +696,12 @@ def render_niche_finder():
         selected_tags = st.multiselect("Tags opcionais", tag_options, key="niche_tags")
         analyse = st.button("Analisar Nichos", type="primary", use_container_width=True, key="niche_analyse")
 
-    if analyse:
+    results = st.session_state.get("niche_results")
+    if results is None or analyse:
         try:
             if start_date and end_date and start_date > end_date:
                 raise NicheAnalysisError("A data inicial não pode ser posterior à data final.")
-            with st.spinner("A analisar clusters e associações…"):
+            with st.spinner("A analisar nichos automaticamente…"):
                 results = run_niche_analysis(
                     str(dataset_path),
                     n_clusters=n_clusters,
@@ -741,18 +714,14 @@ def render_niche_finder():
                 )
             st.session_state["niche_results"] = results
         except (NicheAnalysisError, DatasetError, OSError) as exc:
-            st.error(str(exc))
-
-    results = st.session_state.get("niche_results")
-    if not results:
-        st.subheader("Dataset carregado")
-        st.dataframe(frame.head(100), use_container_width=True, hide_index=True)
-        st.caption(f"{len(frame):,} registos válidos carregados. Ajuste os parâmetros na barra lateral e clique em Analisar Nichos.")
-        return
+            st.error("Não foi possível concluir a análise automática com os filtros actuais.")
+            with st.expander("Detalhes técnicos"):
+                st.caption(str(exc))
+            return
 
     summary = results.get("summary", {})
     metric_cols = st.columns(4)
-    for col, (label, value) in zip(metric_cols, [("Registos filtrados", summary.get("rows_filtered", 0)), ("Clusters", summary.get("cluster_count", 0)), ("Itemsets frequentes", summary.get("frequent_item_count", 0)), ("Regras", summary.get("association_rule_count", 0))]):
+    for col, (label, value) in zip(metric_cols, [("Registos analisados", summary.get("rows_filtered", 0)), ("Clusters", summary.get("cluster_count", 0)), ("Itemsets frequentes", summary.get("frequent_item_count", 0)), ("Regras de associação", summary.get("association_rule_count", 0))]):
         with col:
             card(label, value)
 
@@ -763,7 +732,7 @@ def render_niche_finder():
     keyword = st.text_input("Filtrar palavras-chave nos clusters", key="niche_cluster_keyword", placeholder="Ex.: música, gaming, receitas")
     if keyword.strip():
         cluster_table = cluster_table[cluster_table["palavras"].str.contains(keyword.strip(), case=False, na=False)]
-    tab_clusters, tab_rules, tab_data = st.tabs(["Clusters encontrados", "Regras de associação", "Dados filtrados"])
+    tab_clusters, tab_rules, tab_data = st.tabs(["Clusters encontrados", "Regras de associação", "Dados analisados"])
     with tab_clusters:
         st.dataframe(cluster_table, use_container_width=True, hide_index=True)
         if not points.empty:
@@ -775,10 +744,10 @@ def render_niche_finder():
                 figure.update_layout(legend_title_text="Cluster")
                 st.plotly_chart(figure, use_container_width=True)
             except ImportError:
-                st.warning("A visualização Plotly não está instalada. Execute a instalação incremental do Thunderbolt.")
+                st.error("A visualização da análise não está disponível nesta instalação.")
     with tab_rules:
         if rules_table.empty:
-            st.info("Não foram encontradas regras com o suporte e lift actuais. Reduza o suporte mínimo ou escolha outro filtro.")
+            st.info("Não foram encontradas regras com os filtros actuais. Reduza o suporte mínimo ou escolha outro filtro.")
         else:
             st.dataframe(rules_table, use_container_width=True, hide_index=True)
         if not items_table.empty:
@@ -788,7 +757,6 @@ def render_niche_finder():
         st.dataframe(results["raw_data"], use_container_width=True, hide_index=True)
 
 
-
 def render_videos():
     st.subheader("Vídeos e backlog")
     st.caption("Acompanhamento dos vídeos criados, estados da pipeline e controlos de execução.")

package/app/modules/niche_finder/__init__.py

@@ -1,14 +1,12 @@
 """Streamlit-native Niche Finder integration for Thunderbolt."""
 
 from .core import NicheAnalysisError, run_niche_analysis
-from .data_loader import DATA_DIR, DatasetError, download_kaggle_dataset, list_cached_datasets, save_uploaded_csv
+from .data_loader import DATA_DIR, DatasetError, download_kaggle_dataset
 
 __all__ = [
     "DATA_DIR",
     "DatasetError",
     "NicheAnalysisError",
     "download_kaggle_dataset",
-    "list_cached_datasets",
     "run_niche_analysis",
-    "save_uploaded_csv",
 ]

package/app/modules/niche_finder/data_loader.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
-import io
-import re
 import shutil
 from pathlib import Path
-from typing import BinaryIO
 
 import pandas as pd
 
@@ -39,24 +36,14 @@ OPTIONAL_COLUMNS = (
 
 
 class DatasetError(RuntimeError):
-    """Raised when a Niche Finder dataset cannot be read or validated."""
+    """Raised when the automatic Niche Finder dataset cannot be read or validated."""
 
 
 def ensure_data_dir() -> Path:
     DATA_DIR.mkdir(parents=True, exist_ok=True)
-    (DATA_DIR / "uploads").mkdir(parents=True, exist_ok=True)
     return DATA_DIR
 
 
-def _safe_filename(name: str) -> str:
-    stem = re.sub(r"[^A-Za-z0-9._-]+", "-", Path(name or "dataset.csv").name).strip(".-")
-    if not stem:
-        stem = "dataset.csv"
-    if not stem.lower().endswith(".csv"):
-        stem += ".csv"
-    return stem
-
-
 def _find_csv(root: Path) -> Path | None:
     candidates = sorted(root.rglob("*.csv"))
     if not candidates:
@@ -83,51 +70,35 @@ def _download_with_kagglehub() -> Path | None:
     except TypeError:
         downloaded = kagglehub.dataset_download(DEFAULT_DATASET_SLUG)
     except Exception as exc:  # pragma: no cover - depends on network/provider state
-        raise DatasetError(f"O KaggleHub não conseguiu descarregar o dataset: {exc}") from exc
+        raise DatasetError(f"O Thunderbolt não conseguiu preparar os dados automáticos: {exc}") from exc
     source = _find_csv(Path(downloaded))
     if source is None:
-        raise DatasetError("O download KaggleHub terminou sem encontrar um ficheiro CSV.")
+        raise DatasetError("A preparação automática terminou sem encontrar dados compatíveis.")
     return _copy_csv(source, DEFAULT_DATASET_PATH)
 
 
 def download_kaggle_dataset() -> Path:
-    """Download and cache the public Niche-Finder dataset in Thunderbolt storage."""
+    """Prepare and cache the public Niche-Finder dataset without user interaction."""
     ensure_data_dir()
     if DEFAULT_DATASET_PATH.exists() and DEFAULT_DATASET_PATH.stat().st_size > 0:
         return DEFAULT_DATASET_PATH
     if kagglehub is None:
-        raise DatasetError("A dependência kagglehub não está instalada. Execute novamente a instalação do Thunderbolt.")
+        raise DatasetError("O componente automático de dados não está disponível nesta instalação.")
     downloaded = _download_with_kagglehub()
     if downloaded is None:
-        raise DatasetError("O KaggleHub não devolveu um caminho de dataset válido.")
+        raise DatasetError("O componente automático de dados não devolveu um caminho válido.")
     return downloaded
 
 
-def save_uploaded_csv(payload: bytes | BinaryIO, filename: str) -> Path:
-    """Validate and persist an uploaded CSV under the user's local data directory."""
-    ensure_data_dir()
-    raw = payload.read() if hasattr(payload, "read") else payload
-    if not isinstance(raw, (bytes, bytearray)) or not raw:
-        raise DatasetError("O ficheiro CSV enviado está vazio.")
-    try:
-        frame = pd.read_csv(io.BytesIO(raw))
-        validate_dataset(frame)
-    except (OSError, UnicodeDecodeError, pd.errors.ParserError, pd.errors.EmptyDataError) as exc:
-        raise DatasetError(f"Não foi possível ler o CSV enviado: {exc}") from exc
-    destination = DATA_DIR / "uploads" / _safe_filename(filename)
-    destination.write_bytes(raw)
-    return destination
-
-
 def validate_dataset(frame: pd.DataFrame) -> pd.DataFrame:
-    """Validate the minimal schema and return a normalised copy."""
+    """Validate the internal dataset schema and return a normalised copy."""
     if frame is None or frame.empty:
-        raise DatasetError("O dataset não contém linhas.")
+        raise DatasetError("A fonte automática de dados não contém registos.")
     cleaned = frame.copy()
     cleaned.columns = [str(column).strip() for column in cleaned.columns]
     missing = [column for column in REQUIRED_COLUMNS if column not in cleaned.columns]
     if missing:
-        raise DatasetError("O CSV precisa das colunas: " + ", ".join(missing) + ".")
+        raise DatasetError("A fonte automática não contém as colunas necessárias: " + ", ".join(missing) + ".")
     if "video_tags" not in cleaned.columns:
         cleaned["video_tags"] = ""
     for column in ("view_count", "like_count", "comment_count"):
@@ -138,7 +109,7 @@ def validate_dataset(frame: pd.DataFrame) -> pd.DataFrame:
     cleaned = cleaned.dropna(subset=["publish_date", "view_count", "like_count", "comment_count"])
     cleaned = cleaned[cleaned["title"] != ""].copy()
     if cleaned.empty:
-        raise DatasetError("O dataset não contém linhas válidas depois da normalização.")
+        raise DatasetError("A fonte automática não contém registos válidos depois da normalização.")
     return cleaned.reset_index(drop=True)
 
 
@@ -146,10 +117,5 @@ def load_dataframe(path: str | Path) -> pd.DataFrame:
     try:
         frame = pd.read_csv(path)
     except (OSError, UnicodeDecodeError, pd.errors.ParserError, pd.errors.EmptyDataError) as exc:
-        raise DatasetError(f"Não foi possível ler o dataset: {exc}") from exc
+        raise DatasetError(f"Não foi possível ler a fonte automática de dados: {exc}") from exc
     return validate_dataset(frame)
-
-
-def list_cached_datasets() -> list[Path]:
-    ensure_data_dir()
-    return sorted(DATA_DIR.glob("**/*.csv"))

package/hermes_ui/storage.py

@@ -219,7 +219,7 @@ def seed_blueprints() -> None:
 
 
 def ensure_storage() -> None:
-    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "skills", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs", STORAGE / "music", STORAGE / "voice_previews", NICHES_DATA, NICHES_DATA / "uploads"]:
+    for path in [STATE, BLUEPRINTS / "canais", BLUEPRINTS / "nichos", BLUEPRINTS / "importados", BLUEPRINTS / "brandings", STORAGE / "brand", STORAGE / "scripts", STORAGE / "thumbnails", STORAGE / "videos", STORAGE / "artifacts", STORAGE / "skills", STORAGE / "metadata_cleaner", STORAGE / "metadata_cleaner" / "outputs", STORAGE / "music", STORAGE / "voice_previews", NICHES_DATA]:
         path.mkdir(parents=True, exist_ok=True)
     seed_blueprints()
     for filename, default in DEFAULTS.items():

package/package.json

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

package/scripts/cli.mjs

@@ -81,7 +81,6 @@ function ensureRuntimeStorage() {
     join(storageRoot, "voice_previews"),
     join(storageRoot, "data"),
     join(storageRoot, "data", "niches"),
-    join(storageRoot, "data", "niches", "uploads"),
   ];
   for (const directory of directories) mkdirSync(directory, { recursive: true });
   const seedRoot = resolve(root, "seed", "blueprints");

package/scripts/install.mjs

@@ -112,7 +112,6 @@ function ensureDirs() {
     join(storageRoot, "voice_previews"),
     join(storageRoot, "data"),
     join(storageRoot, "data", "niches"),
-    join(storageRoot, "data", "niches", "uploads"),
   ];
   for (const directory of directories) mkdirSync(directory, { recursive: true });
   copySeedBlueprints(storageRoot);