@danhachuel/pandanews 0.2.2 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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)

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.2", lifespan=lifespan)
+app = FastAPI(title="PandaNews API", version="0.3.0", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
@@ -33,6 +45,8 @@ 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")
 
 

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)

package/backend/core/pipeline.py

@@ -1,6 +1,214 @@
-"""Pipeline de notícias do PandaNews (Fase 3).
+"""Pipeline de notícias do PandaNews.
 
-Coleta RSS -> filtragem por relevância -> rascunho via LLM -> imagem via Gemini
--> revisão humana opcional -> publicação. Disparado por APScheduler conforme a
-frequência de cada blog ou manualmente pela interface.
+Coleta RSS → filtragem por relevância (palavras-chave do tema/região) →
+rascunho via LLM (fallback ordenado NVIDIA → Gemini) → imagem
+fotojornalística via Gemini → status rascunho. Cada etapa registra logs
+(sucesso/erro) por blog; itens já utilizados são deduplicados (tabela vistos).
 """
+from __future__ import annotations
+
+import json
+import re
+
+import feedparser
+from sqlalchemy import select
+
+from backend.core import image_gen, llm_router
+from backend.core.database import Blog, Log, Noticia, SessionLocal, Visto
+
+TEMAS_PALAVRAS: dict[str, list[str]] = {
+    "esporte": [
+        "futebol", "jogo", "time", "campeonato", "gol", "partida", "atleta",
+        "seleção", "torcida", "liga", "olimpíadas", "campeão", "vitória",
+    ],
+    "politica": [
+        "governo", "presidente", "congresso", "eleição", "eleições", "deputado",
+        "senado", "senador", "ministro", "partido", "prefeito", "reforma", "voto",
+    ],
+    "economia": [
+        "mercado", "dólar", "inflação", "juros", "bolsa", "pib", "economia",
+        "impostos", "emprego", "salário", "banco central", "câmbio",
+    ],
+    "tecnologia": [
+        "tecnologia", "inteligência artificial", "app", "startup", "software",
+        "chip", "smartphone", "internet", "dados", "robô", "algoritmo",
+    ],
+    "geral": [],
+}
+
+
+def _log(db, blog_id: int | None, etapa: str, status: str, mensagem: str) -> None:
+    db.add(Log(blog_id=blog_id, etapa=etapa, status=status, mensagem=mensagem[:2000]))
+    db.commit()
+
+
+def _limpar(texto: str, limite: int) -> str:
+    texto = re.sub(r"<[^>]+>", " ", texto or "")
+    return " ".join(texto.split())[:limite]
+
+
+def coletar_itens(db, blog: Blog, fontes: list[str]) -> list[dict]:
+    itens: list[dict] = []
+    for url in fontes:
+        try:
+            feed = feedparser.parse(url)
+            if getattr(feed, "bozo", 0) and not feed.entries:
+                erro = getattr(feed, "bozo_exception", "formato inválido")
+                _log(db, blog.id, "coleta", "erro", f"Falha ao ler feed {url}: {erro}")
+                continue
+            for entrada in feed.entries[:15]:
+                itens.append(
+                    {
+                        "titulo": _limpar(getattr(entrada, "title", ""), 300),
+                        "link": getattr(entrada, "link", "") or "",
+                        "resumo": _limpar(getattr(entrada, "summary", ""), 600),
+                    }
+                )
+            _log(db, blog.id, "coleta", "sucesso", f"{len(feed.entries)} itens coletados de {url}")
+        except Exception as exc:  # noqa: BLE001
+            _log(db, blog.id, "coleta", "erro", f"Exceção ao ler {url}: {exc}")
+    return itens
+
+
+def score_relevancia(item: dict, blog: Blog) -> float:
+    texto = f"{item['titulo']} {item['resumo']}".lower()
+    pontos = 0.0
+    for palavra in TEMAS_PALAVRAS.get(blog.tema, []):
+        if palavra in texto:
+            pontos += 1.0
+    regiao = (blog.regiao or "").strip().lower()
+    if regiao and regiao in texto:
+        pontos += 2.0
+    return pontos
+
+
+def _prompt_redacao(blog: Blog, item: dict) -> str:
+    estilo = (blog.estilo_editorial or "").strip() or "jornalismo claro e direto em português do Brasil"
+    return (
+        "Você é editor-chefe de um blog de notícias. Escreva uma notícia ORIGINAL em "
+        "português do Brasil a partir da fonte abaixo.\n"
+        f"Blog: {blog.nome} — tema: {blog.tema} — região: {blog.regiao}\n"
+        f"Estilo editorial: {estilo}\n"
+        f"Fonte: \"{item['titulo']}\"\n"
+        f"Resumo da fonte: {item['resumo']}\n"
+        "Regras: reescreva com palavras próprias; não invente fatos que não estejam "
+        "na fonte; 3 a 5 parágrafos.\n"
+        'Responda SOMENTE com JSON válido no formato: {"titulo": "...", "resumo": "...", "corpo": "..."}'
+    )
+
+
+def _parse_resposta_llm(texto: str) -> dict:
+    bruto = (texto or "").strip()
+    bruto = re.sub(r"^```(json)?\s*|\s*```$", "", bruto)
+    try:
+        return json.loads(bruto)
+    except Exception:  # noqa: BLE001
+        casado = re.search(r"\{.*\}", bruto, re.DOTALL)
+        if casado:
+            try:
+                return json.loads(casado.group(0))
+            except Exception:  # noqa: BLE001
+                pass
+    return {"titulo": "", "resumo": "", "corpo": bruto}
+
+
+def gerar_noticia(blog_id: int) -> Noticia | None:
+    """Pipeline completo para um blog. Retorna a notícia criada ou None."""
+    db = SessionLocal()
+    try:
+        blog = db.get(Blog, blog_id)
+        if blog is None:
+            _log(db, None, "pipeline", "erro", f"Blog {blog_id} não encontrado")
+            return None
+        fontes = json.loads(blog.fontes_rss or "[]")
+        if not fontes:
+            _log(db, blog.id, "coleta", "erro", "Blog sem fontes RSS configuradas")
+            return None
+
+        # 1. Coleta
+        itens = coletar_itens(db, blog, fontes)
+        if not itens:
+            _log(db, blog.id, "coleta", "erro", "Nenhum item coletado nas fontes")
+            return None
+
+        # 2. Dedup + relevância
+        vistos = {v.url for v in db.scalars(select(Visto).where(Visto.blog_id == blog.id)).all()}
+        novos = [i for i in itens if i["link"] and i["link"] not in vistos]
+        if not novos:
+            _log(db, blog.id, "coleta", "sucesso", "Todos os itens das fontes já haviam sido utilizados")
+            return None
+        novos.sort(key=lambda i: score_relevancia(i, blog), reverse=True)
+        item = novos[0]
+
+        # 3. Redação via LLM (fallback NVIDIA -> Gemini)
+        try:
+            resposta, provedor = llm_router.gerar_texto(db, _prompt_redacao(blog, item), max_tokens=1600)
+        except Exception as exc:  # noqa: BLE001
+            _log(db, blog.id, "redacao", "erro", f"Falha na redação: {exc}")
+            return None
+        dados = _parse_resposta_llm(resposta)
+        titulo = str(dados.get("titulo") or item["titulo"]).strip()
+        resumo = str(dados.get("resumo") or _limpar(item["resumo"], 240)).strip()
+        corpo = str(dados.get("corpo") or resposta).strip()
+        _log(db, blog.id, "redacao", "sucesso", f"Notícia redigida via {provedor}: {titulo}")
+
+        noticia = Noticia(
+            blog_id=blog.id,
+            titulo=titulo,
+            resumo=resumo,
+            corpo=corpo,
+            status="rascunho",
+            llm_provider=provedor,
+            fonte_url=item["link"],
+            fonte_titulo=item["titulo"],
+        )
+        db.add(noticia)
+        db.add(Visto(blog_id=blog.id, url=item["link"]))
+        db.commit()
+        db.refresh(noticia)
+
+        # 4. Imagem (falha não bloqueia: notícia fica sinalizada "sem imagem")
+        try:
+            caminho = image_gen.imagem_para_noticia(db, noticia)
+            noticia.imagem_url = caminho
+            db.commit()
+            _log(db, blog.id, "imagem", "sucesso", f"Imagem gerada: {caminho}")
+        except Exception as exc:  # noqa: BLE001
+            _log(db, blog.id, "imagem", "erro", f"Imagem não gerada: {exc}")
+
+        return noticia
+    finally:
+        db.close()
+
+
+def regenerar_noticia(noticia_id: int) -> Noticia | None:
+    """Re-roda a redação de uma notícia existente a partir da fonte original."""
+    db = SessionLocal()
+    try:
+        noticia = db.get(Noticia, noticia_id)
+        if noticia is None:
+            return None
+        blog = db.get(Blog, noticia.blog_id)
+        if blog is None:
+            return None
+        if not noticia.fonte_titulo and not noticia.fonte_url:
+            _log(db, blog.id, "redacao", "erro", f"Notícia {noticia_id} sem fonte associada")
+            return noticia
+        prompt = _prompt_redacao(
+            blog,
+            {"titulo": noticia.fonte_titulo, "resumo": noticia.resumo or noticia.corpo[:300], "link": noticia.fonte_url},
+        )
+        resposta, provedor = llm_router.gerar_texto(db, prompt, max_tokens=1600)
+        dados = _parse_resposta_llm(resposta)
+        if dados.get("titulo"):
+            noticia.titulo = str(dados["titulo"]).strip()
+        if dados.get("resumo"):
+            noticia.resumo = str(dados["resumo"]).strip()
+        noticia.corpo = str(dados.get("corpo") or resposta).strip()
+        noticia.llm_provider = provedor
+        db.commit()
+        db.refresh(noticia)
+        _log(db, blog.id, "redacao", "sucesso", f"Notícia {noticia_id} regenerada via {provedor}")
+        return noticia
+    finally:
+        db.close()