@danhachuel/pandanews 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 Todas as versões publicadas são registradas aqui antes do publish (regra em AGENTS.md). A etiqueta visual usa PATCH de dois dígitos (ex.: 0.1.00); o registry npm normaliza para a versão canônica (ex.: 0.1.0).
 
+## 0.3.00 (2026-10-24)
+
+- **Pipeline de notícias completo** (Fase 3): coleta RSS (feedparser) → filtragem por relevância (palavras-chave do tema + bônus de região) → redação via LLM com fallback NVIDIA → Gemini (resposta em JSON: título, resumo, corpo) → imagem fotojornalística via Gemini Image salva em `data/imagens/`
+- **Scheduler ativo** (Fase 5): APScheduler com um job por blog ativo (intervalo = frequência do blog), toggle global em Automação liga/desliga de fato, recarregamento automático ao criar/editar/pausar/excluir blogs
+- **Novos endpoints**: `POST /api/v1/noticias/gerar` (dispara o pipeline), `POST /api/v1/noticias/{id}/regenerar`, `GET/POST /api/v1/imagens` (galeria, arquivo e geração manual por prompt), `GET /api/v1/automacao/status` (próxima execução por blog), `POST /api/v1/automacao/executar`
+- Dedup de itens: tabela `vistos` evita reutilizar o mesmo item de feed; migração leve adiciona `fonte_url`/`fonte_titulo` às notícias em bancos existentes
+- Logs de execução por etapa (coleta/redação/imagem/pipeline) visíveis na página Logs
+- UI: botão "Gerar notícia agora" com stepper de progresso (Gradiente de Meta: coletando → redigindo → gerando imagem → salvo), ação Regenerar nas notícias, galeria real de imagens com geração manual e próxima execução por blog na Automação
+
+## 0.2.02 (2026-10-24)
+
+- **O sistema NUNCA abre o navegador**: o app exibe o endereço no terminal e o usuário decide quando abrir (dependência `open` removida)
+- **Terminal limpo**: logs de acesso do uvicorn (stdout — `GET /health`, `GET /api/v1/*` etc.) vão apenas para `data/backend.log`; o console mantém somente stderr (banner de inicialização, WARNING/ERROR e tracebacks)
+- **Fallback de porta também para o backend**: se 8000 estiver ocupada (ex.: outra instância), o backend sobe em 8001, 8002... e o proxy da UI segue automaticamente — junto com o fallback já existente da UI (4030, 4031...)
+- Novo endpoint `GET /health` na raiz (200 OK) para clientes que esperam esse caminho — elimina os 404; o health canônico segue em `/api/v1/health`
+- `data/backend.log` continua registrando TODAS as requisições (incluindo `/health`) para auditoria — o filtro no logger `uvicorn.access` (Python) foi deliberadamente evitado: removeria `/health` também do arquivo de auditoria; o silenciamento é feito apenas no console
+
 ## 0.2.01 (2026-10-23)
 
 - **Blindagem do backend**: saída do uvicorn espelhada no console e gravada em `<home>/data/backend.log` — queda anormal registra o motivo para diagnóstico

package/README.md

@@ -34,11 +34,12 @@ npx --yes @danhachuel/pandanews install
 
 O runtime fica em `~/.pandanews` (sobrescreva com a variável de ambiente `PANDANEWS_HOME`) — **upgrades de versão não reinstalam** o que já existe: o instalador detecta Python, dependências e dados já presentes e só instala o que falta.
 
-## Status (versão 0.2.00)
+## Status (versão 0.3.00)
 
-- UI React completa: Dashboard, Blogs, Notícias, Imagens, Automação, Configurações e Logs
-- Backend: CRUD de blogs, configurações NVIDIA/Gemini com teste de conexão, dashboard e logs — SQLite local
-- Próximo: pipeline de geração de notícias (Fase 3) e scheduler ativo (Fase 5)
+- **Pipeline completo**: coleta RSS → redação via LLM (fallback NVIDIA → Gemini) → imagem fotojornalística via Gemini Image → rascunho para revisão
+- **Scheduler ativo**: um job por blog ativo (frequência configurável), toggle global em Automação e execução imediata (⚡ Gerar notícia agora)
+- UI completa: Dashboard, Blogs, Notícias (gerar/regenerar/aprovar), Imagens (galeria + geração manual), Automação, Configurações, Logs
+- Próximo (Fase 6): detecção automática de Supabase, migração SQLite → Supabase e revisão das 7 leis de UX
 
 - `npx @danhachuel/pandanews` instala tudo junto (Python portátil + dependências + banco local) e sobe o backend em 127.0.0.1:8000 com página em 127.0.0.1:4030 — se a porta estiver ocupada, usa a seguinte automaticamente (4031, 4032, ...)
 - A UI React completa (Dashboard, Blogs, Notícias, Imagens, Automação, Configurações) e o pipeline de notícias chegam nas próximas versões (Fases 1 a 3 do plano — ver `CHANGELOG.md`)

package/backend/app/main.py

@@ -1,25 +1,37 @@
 """PandaNews API — FastAPI.
 
-Fase 1: CRUD de blogs, configurações (keys mascaradas), teste de LLM,
-dashboard com métricas/onboarding, notícias e logs. SQLite local criado
-automaticamente no startup (init_db). CORS liberado para a UI local.
+Fases 1, 3 e 5: CRUD de blogs, configurações (keys mascaradas), teste de LLM,
+dashboard, notícias (com geração via pipeline), imagens, logs, automação com
+scheduler ativo por blog. SQLite local criado automaticamente no startup.
+CORS liberado para a UI local (localhost em qualquer porta).
 """
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from backend.app.routers import blogs, configuracoes, dashboard, llm, logs, noticias
-from backend.core.database import init_db
+from backend.app.routers import automacao, blogs, configuracoes, dashboard, imagens, llm, logs, noticias
+from backend.core.database import SessionLocal, init_db
+from backend.core.llm_router import get_config
 
 
 @asynccontextmanager
 async def lifespan(_: FastAPI):
     init_db()
+    from backend.core import scheduler
+
+    db = SessionLocal()
+    try:
+        if get_config(db, "scheduler_ativo", "true") == "true":
+            scheduler.iniciar()
+            scheduler.recarregar()
+    finally:
+        db.close()
     yield
+    scheduler.parar()
 
 
-app = FastAPI(title="PandaNews API", version="0.2.1", lifespan=lifespan)
+app = FastAPI(title="PandaNews API", version="0.3.0", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
@@ -33,9 +45,17 @@ app.include_router(configuracoes.router, prefix="/api/v1")
 app.include_router(dashboard.router, prefix="/api/v1")
 app.include_router(llm.router, prefix="/api/v1")
 app.include_router(noticias.router, prefix="/api/v1")
+app.include_router(imagens.router, prefix="/api/v1")
+app.include_router(automacao.router, prefix="/api/v1")
 app.include_router(logs.router, prefix="/api/v1")
 
 
 @app.get("/api/v1/health")
 def health() -> dict:
     return {"status": "ok", "service": "pandanews", "version": app.version}
+
+
+@app.get("/health")
+def health_root() -> dict:
+    """Alias na raiz para clientes que esperam /health (extensões, monitores)."""
+    return {"status": "ok", "service": "pandanews", "version": app.version}

package/backend/app/routers/automacao.py

@@ -0,0 +1,47 @@
+"""Automação (/api/v1/automacao): estado do scheduler e execução imediata."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from backend.core import scheduler
+from backend.core.database import Blog, get_db
+
+router = APIRouter(prefix="/automacao", tags=["automacao"])
+
+
+class BlogIdIn(BaseModel):
+    blog_id: int
+
+
+@router.get("/status")
+def status(db: Session = Depends(get_db)) -> dict:
+    jobs = {job["blog_id"]: job["proxima_execucao"] for job in scheduler.jobs()}
+    blogs = db.scalars(select(Blog).where(Blog.status == "ativo")).all()
+    return {
+        "ativo": scheduler.esta_ativo(),
+        "jobs": [
+            {
+                "blog_id": blog.id,
+                "nome": blog.nome,
+                "frequencia_horas": blog.frequencia_horas,
+                "proxima_execucao": jobs.get(blog.id),
+            }
+            for blog in blogs
+        ],
+    }
+
+
+@router.post("/executar")
+def executar_agora(payload: BlogIdIn) -> dict:
+    from backend.core import pipeline
+
+    noticia = pipeline.gerar_noticia(payload.blog_id)
+    if noticia is None:
+        return {
+            "ok": False,
+            "detail": "Nenhuma notícia nova: sem itens nas fontes, todos já utilizados ou erro na geração — verifique os Logs.",
+        }
+    return {"ok": True, "noticia_id": noticia.id, "titulo": noticia.titulo}

package/backend/app/routers/blogs.py

@@ -41,6 +41,13 @@ def obter_blog(blog_id: int, db: Session = Depends(get_db)) -> dict:
     return blog_to_dict(blog)
 
 
+def _sync_scheduler() -> None:
+    from backend.core import scheduler
+
+    if scheduler.esta_ativo():
+        scheduler.recarregar()
+
+
 @router.post("", status_code=201)
 def criar_blog(payload: BlogIn, db: Session = Depends(get_db)) -> dict:
     blog = Blog(
@@ -56,6 +63,7 @@ def criar_blog(payload: BlogIn, db: Session = Depends(get_db)) -> dict:
     db.add(Log(etapa="blog", status="sucesso", mensagem=f"Blog criado: {payload.nome}"))
     db.commit()
     db.refresh(blog)
+    _sync_scheduler()
     return blog_to_dict(blog)
 
 
@@ -71,6 +79,7 @@ def atualizar_blog(blog_id: int, payload: BlogPatch, db: Session = Depends(get_d
         setattr(blog, key, value)
     db.commit()
     db.refresh(blog)
+    _sync_scheduler()
     return blog_to_dict(blog)
 
 
@@ -85,3 +94,4 @@ def excluir_blog(blog_id: int, db: Session = Depends(get_db)) -> None:
     db.delete(blog)
     db.add(Log(etapa="blog", status="sucesso", mensagem=f"Blog excluído: {blog.nome}"))
     db.commit()
+    _sync_scheduler()

package/backend/app/routers/configuracoes.py

@@ -55,4 +55,16 @@ def salvar_configuracoes(payload: ConfiguracoesPatch, db: Session = Depends(get_
         else:
             row.valor = str(valor)
     db.commit()
+    if "scheduler_ativo" in data:
+        from backend.core import scheduler
+
+        bruto = data["scheduler_ativo"]
+        ligado = bruto if isinstance(bruto, bool) else str(bruto).lower() == "true"
+        if ligado and not scheduler.esta_ativo():
+            scheduler.iniciar()
+            scheduler.recarregar()
+        elif ligado:
+            scheduler.recarregar()
+        else:
+            scheduler.parar()
     return obter_configuracoes(db)

package/backend/app/routers/imagens.py

@@ -0,0 +1,49 @@
+"""Imagens (/api/v1/imagens): galeria, arquivo e geração manual."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from backend.core.config import IMAGES_DIR
+from backend.core.database import Noticia, get_db
+
+router = APIRouter(prefix="/imagens", tags=["imagens"])
+
+
+class PromptIn(BaseModel):
+    prompt: str
+
+
+@router.get("")
+def listar_imagens(db: Session = Depends(get_db)) -> list[dict]:
+    noticias = db.scalars(
+        select(Noticia).where(Noticia.imagem_url != "").order_by(Noticia.created_at.desc()).limit(100)
+    ).all()
+    return [
+        {"noticia_id": n.id, "url": n.imagem_url, "titulo": n.titulo, "created_at": n.created_at}
+        for n in noticias
+    ]
+
+
+@router.get("/{nome}")
+def servir_imagem(nome: str) -> FileResponse:
+    if "/" in nome or "\\" in nome or ".." in nome or not nome.endswith(".png"):
+        raise HTTPException(status_code=400, detail="Nome de arquivo inválido")
+    caminho = IMAGES_DIR / nome
+    if not caminho.exists():
+        raise HTTPException(status_code=404, detail="Imagem não encontrada")
+    return FileResponse(caminho, media_type="image/png")
+
+
+@router.post("/gerar")
+def gerar_imagem_manual(payload: PromptIn, db: Session = Depends(get_db)) -> dict:
+    from backend.core import image_gen
+
+    try:
+        url = image_gen.imagem_manual(db, payload.prompt.strip())
+        return {"ok": True, "url": url}
+    except Exception as exc:  # noqa: BLE001
+        return {"ok": False, "detail": str(exc)}

package/backend/app/routers/noticias.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
@@ -11,6 +12,51 @@ from backend.core.database import Noticia, get_db
 router = APIRouter(prefix="/noticias", tags=["noticias"])
 
 
+class GerarIn(BaseModel):
+    blog_id: int
+
+
+def _serializar(n: Noticia) -> dict:
+    return {
+        "id": n.id,
+        "blog_id": n.blog_id,
+        "titulo": n.titulo,
+        "corpo": n.corpo,
+        "resumo": n.resumo,
+        "imagem_url": n.imagem_url,
+        "status": n.status,
+        "llm_provider": n.llm_provider,
+        "fonte_url": n.fonte_url,
+        "fonte_titulo": n.fonte_titulo,
+        "created_at": n.created_at,
+    }
+
+
+@router.post("/gerar", status_code=201)
+def gerar_noticia(payload: GerarIn) -> dict:
+    from backend.core import pipeline
+
+    noticia = pipeline.gerar_noticia(payload.blog_id)
+    if noticia is None:
+        raise HTTPException(
+            status_code=409,
+            detail="Nenhuma notícia nova: sem itens nas fontes, todos já utilizados ou erro na geração — verifique os Logs.",
+        )
+    return _serializar(noticia)
+
+
+@router.post("/{noticia_id}/regenerar")
+def regenerar_noticia(noticia_id: int) -> dict:
+    from backend.core import pipeline
+
+    noticia = pipeline.regenerar_noticia(noticia_id)
+    if noticia is None:
+        raise HTTPException(status_code=404, detail="Notícia (ou blog/fonte) não encontrada")
+    if not noticia.fonte_titulo and not noticia.fonte_url:
+        raise HTTPException(status_code=422, detail="Notícia sem fonte associada — use Gerar notícia para criar uma nova")
+    return _serializar(noticia)
+
+
 @router.get("")
 def listar_noticias(
     blog_id: int | None = None,

package/backend/core/database.py

@@ -55,9 +55,22 @@ class Noticia(Base):
     imagem_url: Mapped[str] = mapped_column(String(500), default="")
     status: Mapped[str] = mapped_column(String(20), default="rascunho", index=True)
     llm_provider: Mapped[str] = mapped_column(String(50), default="")
+    fonte_url: Mapped[str] = mapped_column(String(600), default="")
+    fonte_titulo: Mapped[str] = mapped_column(Text, default="")
     created_at: Mapped[datetime] = mapped_column(default=_now, index=True)
 
 
+class Visto(Base):
+    """Itens de feed já utilizados por blog (dedup do pipeline)."""
+
+    __tablename__ = "vistos"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    blog_id: Mapped[int] = mapped_column(ForeignKey("blogs.id"), index=True)
+    url: Mapped[str] = mapped_column(String(600))
+    created_at: Mapped[datetime] = mapped_column(default=_now)
+
+
 class Configuracao(Base):
     __tablename__ = "configuracoes"
 
@@ -78,6 +91,24 @@ class Log(Base):
 
 def init_db() -> None:
     Base.metadata.create_all(bind=engine)
+    _migrate()
+
+
+def _migrate() -> None:
+    """Migrações leves para bancos existentes (SQLite)."""
+    if not DB_URL.startswith("sqlite"):
+        return
+    from sqlalchemy import text
+
+    with engine.connect() as conn:
+        colunas = [row[1] for row in conn.execute(text("PRAGMA table_info(noticias)"))]
+        for coluna, ddl in (
+            ("fonte_url", "VARCHAR(600) DEFAULT ''"),
+            ("fonte_titulo", "TEXT DEFAULT ''"),
+        ):
+            if coluna not in colunas:
+                conn.execute(text(f"ALTER TABLE noticias ADD COLUMN {coluna} {ddl}"))
+        conn.commit()
 
 
 def get_db():

package/backend/core/image_gen.py

@@ -1,6 +1,84 @@
-"""Geração de imagens do PandaNews (Fase 3).
+"""Geração de imagens do PandaNews (Gemini Image).
 
-Gemini Image API com prompt fotojornalístico a partir de palavras-chave da
-notícia; imagens salvas em data/imagens/{noticia_id}.png. Se falhar, a notícia
-segue sem imagem e é sinalizada na UI para ação manual.
+Extrai palavras-chave do título/resumo da notícia (TF simples), monta um
+prompt fotojornalístico e chama a Gemini Image API. A imagem é salva em
+<home>/data/imagens/ e servida por /api/v1/imagens/{nome}. Se a geração
+falhar, a notícia segue sem imagem (sinalizada na UI) — o pipeline não para.
 """
+from __future__ import annotations
+
+import base64
+import re
+from datetime import datetime, timezone
+
+import httpx
+
+from backend.core.config import IMAGES_DIR
+from backend.core.llm_router import get_config
+
+IMAGE_MODEL_DEFAULT = "gemini-3.1-flash-image"
+
+STOPWORDS = set(
+    "a o e de da do das dos em no na nos nas um uma com para por que se ao aos "
+    "as os mais como onde quando após sobre entre sua seu suas seus pelo pela "
+    "isso esse essa isto este esta foi ser ter pela pelos".split()
+)
+
+
+def extrair_palavras_chave(texto: str, max_palavras: int = 10) -> list[str]:
+    palavras = re.findall(r"[a-záàâãéêíóôõúüç]{4,}", (texto or "").lower())
+    contagem: dict[str, int] = {}
+    for palavra in palavras:
+        if palavra in STOPWORDS:
+            continue
+        contagem[palavra] = contagem.get(palavra, 0) + 1
+    ordenadas = sorted(contagem, key=contagem.get, reverse=True)
+    return ordenadas[:max_palavras]
+
+
+def gerar_imagem(db, prompt_visual: str) -> bytes:
+    """Chama a Gemini Image API e devolve os bytes da imagem."""
+    api_key = get_config(db, "google_api_key")
+    if not api_key:
+        raise RuntimeError("API key do Google Gemini não configurada — adicione em Configurações para gerar imagens.")
+    modelo = get_config(db, "google_image_model", IMAGE_MODEL_DEFAULT)
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{modelo}:generateContent"
+    payload = {
+        "contents": [{"parts": [{"text": prompt_visual}]}],
+        "generationConfig": {"responseModalities": ["IMAGE"]},
+    }
+    resposta = httpx.post(url, json=payload, headers={"x-goog-api-key": api_key}, timeout=180.0)
+    if resposta.status_code != 200:
+        raise RuntimeError(f"Gemini Image respondeu {resposta.status_code}: {resposta.text[:300]}")
+    dados = resposta.json()
+    for candidato in dados.get("candidates", []):
+        for parte in candidato.get("content", {}).get("parts", []):
+            inline = parte.get("inlineData") or parte.get("inline_data")
+            if inline and inline.get("data"):
+                return base64.b64decode(inline["data"])
+    raise RuntimeError("Gemini Image não retornou imagem — verifique o modelo configurado em Configurações.")
+
+
+def _salvar(dados: bytes, nome: str) -> str:
+    IMAGES_DIR.mkdir(parents=True, exist_ok=True)
+    (IMAGES_DIR / nome).write_bytes(dados)
+    return f"/api/v1/imagens/{nome}"
+
+
+def imagem_para_noticia(db, noticia) -> str:
+    """Gera a imagem de capa de uma notícia (estilo fotojornalístico)."""
+    chaves = extrair_palavras_chave(f"{noticia.titulo} {noticia.resumo}")
+    prompt = (
+        "Fotografia jornalística profissional, iluminação natural, realista, "
+        "sem texto ou marca d'água, retratando: "
+        f"{', '.join(chaves) if chaves else (noticia.titulo or 'notícias gerais')}"
+    )
+    dados = gerar_imagem(db, prompt)
+    return _salvar(dados, f"{noticia.id}.png")
+
+
+def imagem_manual(db, prompt: str) -> str:
+    """Gera uma imagem a partir de prompt livre (página Imagens)."""
+    dados = gerar_imagem(db, prompt)
+    nome = f"manual-{int(datetime.now(timezone.utc).timestamp() * 1000)}.png"
+    return _salvar(dados, nome)