@danhachuel/pandanews 0.1.3 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 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.2.00 (2026-10-23)
+
+- **UI React completa** (Fase 2): Vite + TypeScript + Tailwind, sidebar com 7 seções, topbar com seletor de blog e tema claro/escuro
+  - Dashboard: checklist de onboarding (efeito Zeigarnik) com barra de progresso, estatísticas, gráfico de geração dos últimos 7 dias e últimos erros
+  - Blogs: cards, criação em assistente de 3 passos (Lei de Hick), edição, pausar/ativar e exclusão com confirmação modal (Lei de Jakob)
+  - Notícias: filtros por blog/status, badges de status (rascunho em âmbar — von Restorff), aprovar/rejeitar e edição manual
+  - Configurações: NVIDIA NIM e Google Gemini com keys mascaradas e teste de conexão real, ordem de fallback reordenável, banco SQLite/Supabase e agendamento — em blocos expansíveis (Lei de Miller)
+  - Automação: toggle global do scheduler e por blog; Imagens e Logs com empty states
+- **Favicon de urso-panda** 🐼 nas guias do navegador (SVG) — também no placeholder
+- **Backend Fase 1**: SQLite com tabelas blogs/noticias/configuracoes/logs criadas no startup, CRUD de blogs (`/api/v1/blogs`), configurações mascaradas (`/api/v1/configuracoes`), teste de LLM real por provedor (`/api/v1/llm/test`), dashboard (`/api/v1/dashboard`), notícias e logs
+- `start.js`: proxy `/api` → backend (UI same-origin) e fallback SPA para rotas do React Router
+- Workflow: build do frontend antes do publish (`frontend/dist` entra no tarball)
+
 ## 0.1.03 (2026-10-23)
 
 - Runtime movido para um diretório **estável por usuário** (`~/.pandanews`, sobrescrevível via `PANDANEWS_HOME`): upgrades de versão do pacote não reinstalam mais Python/dependências — o instalador detecta o que já existe e só instala o que falta

package/README.md

@@ -34,7 +34,11 @@ 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.1.03)
+## Status (versão 0.2.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)
 
 - `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,13 +1,25 @@
 """PandaNews API — FastAPI.
 
-Fase 0/1: aplicação mínima com endpoint de health e CORS liberado para a UI
-local (localhost/127.0.0.1 em qualquer porta — a UI usa porta dinâmica a partir
-de 4030). CRUD de blogs e configurações chegam na Fase 1.
+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.
 """
+from contextlib import asynccontextmanager
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-app = FastAPI(title="PandaNews API", version="0.1.3")
+from backend.app.routers import blogs, configuracoes, dashboard, llm, logs, noticias
+from backend.core.database import init_db
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    init_db()
+    yield
+
+
+app = FastAPI(title="PandaNews API", version="0.2.0", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
@@ -16,6 +28,13 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+app.include_router(blogs.router, prefix="/api/v1")
+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(logs.router, prefix="/api/v1")
+
 
 @app.get("/api/v1/health")
 def health() -> dict:

package/backend/app/routers/blogs.py

@@ -0,0 +1,87 @@
+"""CRUD de blogs (/api/v1/blogs)."""
+from __future__ import annotations
+
+import json
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from backend.app.schemas import BlogIn, BlogPatch
+from backend.core.database import Blog, Log, get_db
+
+router = APIRouter(prefix="/blogs", tags=["blogs"])
+
+
+def blog_to_dict(b: Blog) -> dict:
+    return {
+        "id": b.id,
+        "nome": b.nome,
+        "tema": b.tema,
+        "regiao": b.regiao,
+        "fontes_rss": json.loads(b.fontes_rss or "[]"),
+        "estilo_editorial": b.estilo_editorial,
+        "frequencia_horas": b.frequencia_horas,
+        "status": b.status,
+        "created_at": b.created_at,
+    }
+
+
+@router.get("")
+def listar_blogs(db: Session = Depends(get_db)) -> list[dict]:
+    blogs = db.scalars(select(Blog).order_by(Blog.created_at.desc())).all()
+    return [blog_to_dict(b) for b in blogs]
+
+
+@router.get("/{blog_id}")
+def obter_blog(blog_id: int, db: Session = Depends(get_db)) -> dict:
+    blog = db.get(Blog, blog_id)
+    if blog is None:
+        raise HTTPException(status_code=404, detail="Blog não encontrado")
+    return blog_to_dict(blog)
+
+
+@router.post("", status_code=201)
+def criar_blog(payload: BlogIn, db: Session = Depends(get_db)) -> dict:
+    blog = Blog(
+        nome=payload.nome,
+        tema=payload.tema,
+        regiao=payload.regiao,
+        fontes_rss=json.dumps([u.strip() for u in payload.fontes_rss if u.strip()]),
+        estilo_editorial=payload.estilo_editorial,
+        frequencia_horas=payload.frequencia_horas,
+        status=payload.status,
+    )
+    db.add(blog)
+    db.add(Log(etapa="blog", status="sucesso", mensagem=f"Blog criado: {payload.nome}"))
+    db.commit()
+    db.refresh(blog)
+    return blog_to_dict(blog)
+
+
+@router.patch("/{blog_id}")
+def atualizar_blog(blog_id: int, payload: BlogPatch, db: Session = Depends(get_db)) -> dict:
+    blog = db.get(Blog, blog_id)
+    if blog is None:
+        raise HTTPException(status_code=404, detail="Blog não encontrado")
+    data = payload.model_dump(exclude_none=True)
+    if "fontes_rss" in data:
+        blog.fontes_rss = json.dumps([u.strip() for u in data.pop("fontes_rss") if u.strip()])
+    for key, value in data.items():
+        setattr(blog, key, value)
+    db.commit()
+    db.refresh(blog)
+    return blog_to_dict(blog)
+
+
+@router.delete("/{blog_id}", status_code=204)
+def excluir_blog(blog_id: int, db: Session = Depends(get_db)) -> None:
+    from backend.core.database import Noticia
+
+    blog = db.get(Blog, blog_id)
+    if blog is None:
+        raise HTTPException(status_code=404, detail="Blog não encontrado")
+    db.query(Noticia).filter(Noticia.blog_id == blog_id).delete()
+    db.delete(blog)
+    db.add(Log(etapa="blog", status="sucesso", mensagem=f"Blog excluído: {blog.nome}"))
+    db.commit()

package/backend/app/routers/configuracoes.py

@@ -0,0 +1,58 @@
+"""Configurações (/api/v1/configuracoes) — API keys mascaradas, sem travas."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from backend.app.schemas import ConfiguracoesPatch
+from backend.core.config import DEFAULT_LLM_BASE_URLS, DEFAULT_LLM_MODELS, SUPABASE_URL
+from backend.core.database import Configuracao, get_db
+from backend.core.llm_router import get_config
+
+router = APIRouter(prefix="/configuracoes", tags=["configuracoes"])
+
+SECRET_KEYS = ("nvidia_api_key", "google_api_key", "supabase_service_role_key")
+
+
+def _mask(value: str) -> dict:
+    if not value:
+        return {"configured": False, "preview": ""}
+    if len(value) <= 8:
+        return {"configured": True, "preview": "••••"}
+    return {"configured": True, "preview": f"{value[:4]}••••{value[-4:]}"}
+
+
+@router.get("")
+def obter_configuracoes(db: Session = Depends(get_db)) -> dict:
+    return {
+        "nvidia_api_key": _mask(get_config(db, "nvidia_api_key")),
+        "nvidia_base_url": get_config(db, "nvidia_base_url", DEFAULT_LLM_BASE_URLS["nvidia"]),
+        "nvidia_model": get_config(db, "nvidia_model", DEFAULT_LLM_MODELS["nvidia"]),
+        "google_api_key": _mask(get_config(db, "google_api_key")),
+        "google_base_url": get_config(db, "google_base_url", DEFAULT_LLM_BASE_URLS["google"]),
+        "google_model": get_config(db, "google_model", DEFAULT_LLM_MODELS["google"]),
+        "llm_fallback_ordem": get_config(db, "llm_fallback_ordem", "nvidia,google"),
+        "db_backend": get_config(db, "db_backend", "supabase" if SUPABASE_URL else "sqlite"),
+        "supabase_url": SUPABASE_URL,
+        "supabase_service_role_key": _mask(get_config(db, "supabase_service_role_key")),
+        "scheduler_ativo": get_config(db, "scheduler_ativo", "true") == "true",
+        "intervalo_padrao_horas": int(get_config(db, "intervalo_padrao_horas", "6") or 6),
+    }
+
+
+@router.put("")
+def salvar_configuracoes(payload: ConfiguracoesPatch, db: Session = Depends(get_db)) -> dict:
+    data = payload.model_dump(exclude_none=True)
+    for chave, valor in data.items():
+        if chave in SECRET_KEYS and isinstance(valor, str) and valor.strip() == "":
+            continue  # vazio não apaga segredo existente (UX sem travas)
+        if isinstance(valor, bool):
+            valor = "true" if valor else "false"
+        row = db.get(Configuracao, chave)
+        if row is None:
+            row = Configuracao(chave=chave, valor=str(valor))
+            db.add(row)
+        else:
+            row.valor = str(valor)
+    db.commit()
+    return obter_configuracoes(db)

package/backend/app/routers/dashboard.py

@@ -0,0 +1,59 @@
+"""Dashboard (/api/v1/dashboard): métricas, onboarding e últimos erros."""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from fastapi import APIRouter, Depends
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from backend.core.database import Blog, Log, Noticia, get_db
+from backend.core.llm_router import get_config
+
+router = APIRouter(prefix="/dashboard", tags=["dashboard"])
+
+
+@router.get("")
+def estatisticas(db: Session = Depends(get_db)) -> dict:
+    agora = datetime.now(timezone.utc)
+    inicio_hoje = agora.replace(hour=0, minute=0, second=0, microsecond=0)
+
+    blogs_total = db.scalar(select(func.count(Blog.id))) or 0
+    blogs_ativos = db.scalar(select(func.count(Blog.id)).where(Blog.status == "ativo")) or 0
+    noticias_total = db.scalar(select(func.count(Noticia.id))) or 0
+    noticias_hoje = db.scalar(select(func.count(Noticia.id)).where(Noticia.created_at >= inicio_hoje)) or 0
+    noticias_pendentes = db.scalar(select(func.count(Noticia.id)).where(Noticia.status == "rascunho")) or 0
+    erros_total = db.scalar(select(func.count(Log.id)).where(Log.status == "erro")) or 0
+
+    geracao: list[dict] = []
+    for offset in range(6, -1, -1):
+        dia = (agora - timedelta(days=offset)).replace(hour=0, minute=0, second=0, microsecond=0)
+        dia_fim = dia + timedelta(days=1)
+        total = db.scalar(select(func.count(Noticia.id)).where(Noticia.created_at >= dia, Noticia.created_at < dia_fim)) or 0
+        geracao.append({"data": dia.date().isoformat(), "total": total})
+
+    ultimos_erros = [
+        {"id": e.id, "blog_id": e.blog_id, "etapa": e.etapa, "mensagem": e.mensagem, "created_at": e.created_at}
+        for e in db.scalars(select(Log).where(Log.status == "erro").order_by(Log.created_at.desc()).limit(5)).all()
+    ]
+
+    llm_configurado = bool(get_config(db, "nvidia_api_key") or get_config(db, "google_api_key"))
+    onboarding = {
+        "llm_configurado": llm_configurado,
+        "tem_blog": blogs_total > 0,
+        "tem_noticia": noticias_total > 0,
+    }
+    onboarding["concluidos"] = sum(1 for v in onboarding.values() if v)
+
+    return {
+        "blogs_total": blogs_total,
+        "blogs_ativos": blogs_ativos,
+        "noticias_total": noticias_total,
+        "noticias_hoje": noticias_hoje,
+        "noticias_pendentes": noticias_pendentes,
+        "erros_total": erros_total,
+        "scheduler_ativo": get_config(db, "scheduler_ativo", "true") == "true",
+        "geracao_7dias": geracao,
+        "ultimos_erros": ultimos_erros,
+        "onboarding": onboarding,
+    }

package/backend/app/routers/llm.py

@@ -0,0 +1,16 @@
+"""Teste de conexão LLM (/api/v1/llm/test) — por provedor, sem travas."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from backend.app.schemas import LlmTestIn
+from backend.core.database import get_db
+from backend.core.llm_router import test_provider
+
+router = APIRouter(prefix="/llm", tags=["llm"])
+
+
+@router.post("/test")
+def testar_llm(payload: LlmTestIn, db: Session = Depends(get_db)) -> dict:
+    return test_provider(db, payload.provider.strip().lower())

package/backend/app/routers/logs.py

@@ -0,0 +1,38 @@
+"""Logs de execução (/api/v1/logs)."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from backend.core.database import Log, get_db
+
+router = APIRouter(prefix="/logs", tags=["logs"])
+
+
+@router.get("")
+def listar_logs(
+    blog_id: int | None = None,
+    etapa: str | None = None,
+    status: str | None = None,
+    limit: int = 200,
+    db: Session = Depends(get_db),
+) -> list[dict]:
+    query = select(Log).order_by(Log.created_at.desc()).limit(min(limit, 1000))
+    if blog_id is not None:
+        query = query.where(Log.blog_id == blog_id)
+    if etapa:
+        query = query.where(Log.etapa == etapa)
+    if status:
+        query = query.where(Log.status == status)
+    return [
+        {
+            "id": l.id,
+            "blog_id": l.blog_id,
+            "etapa": l.etapa,
+            "status": l.status,
+            "mensagem": l.mensagem,
+            "created_at": l.created_at,
+        }
+        for l in db.scalars(query).all()
+    ]

package/backend/app/routers/noticias.py

@@ -0,0 +1,65 @@
+"""Notícias (/api/v1/noticias): listagem, filtros e revisão humana."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from backend.app.schemas import NoticiaPatch, STATUS_NOTICIA
+from backend.core.database import Noticia, get_db
+
+router = APIRouter(prefix="/noticias", tags=["noticias"])
+
+
+@router.get("")
+def listar_noticias(
+    blog_id: int | None = None,
+    status: str | None = None,
+    limit: int = 100,
+    db: Session = Depends(get_db),
+) -> list[dict]:
+    query = select(Noticia).order_by(Noticia.created_at.desc()).limit(min(limit, 500))
+    if blog_id is not None:
+        query = query.where(Noticia.blog_id == blog_id)
+    if status:
+        query = query.where(Noticia.status == status)
+    noticias = db.scalars(query).all()
+    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,
+            "created_at": n.created_at,
+        }
+        for n in noticias
+    ]
+
+
+@router.patch("/{noticia_id}")
+def atualizar_noticia(noticia_id: int, payload: NoticiaPatch, db: Session = Depends(get_db)) -> dict:
+    noticia = db.get(Noticia, noticia_id)
+    if noticia is None:
+        raise HTTPException(status_code=404, detail="Notícia não encontrada")
+    data = payload.model_dump(exclude_none=True)
+    if "status" in data and data["status"] not in STATUS_NOTICIA:
+        raise HTTPException(status_code=422, detail=f"Status inválido. Use: {', '.join(STATUS_NOTICIA)}")
+    for key, value in data.items():
+        setattr(noticia, key, value)
+    db.commit()
+    db.refresh(noticia)
+    return {
+        "id": noticia.id,
+        "blog_id": noticia.blog_id,
+        "titulo": noticia.titulo,
+        "corpo": noticia.corpo,
+        "resumo": noticia.resumo,
+        "imagem_url": noticia.imagem_url,
+        "status": noticia.status,
+        "llm_provider": noticia.llm_provider,
+        "created_at": noticia.created_at,
+    }

package/backend/app/schemas.py

@@ -1 +1,71 @@
-"""Schemas Pydantic do PandaNews (preenchidos na Fase 1)."""
+"""Schemas Pydantic do PandaNews (entrada e saída das rotas)."""
+from __future__ import annotations
+
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+TEMAS = ["geral", "esporte", "politica", "economia", "tecnologia"]
+STATUS_BLOG = ["ativo", "pausado"]
+STATUS_NOTICIA = ["rascunho", "aprovado", "rejeitado", "publicado"]
+
+
+class BlogIn(BaseModel):
+    nome: str = Field(min_length=1, max_length=200)
+    tema: str = "geral"
+    regiao: str = "Brasil"
+    fontes_rss: List[str] = []
+    estilo_editorial: str = ""
+    frequencia_horas: int = Field(default=6, ge=1, le=168)
+    status: str = "ativo"
+
+
+class BlogPatch(BaseModel):
+    nome: Optional[str] = None
+    tema: Optional[str] = None
+    regiao: Optional[str] = None
+    fontes_rss: Optional[List[str]] = None
+    estilo_editorial: Optional[str] = None
+    frequencia_horas: Optional[int] = Field(default=None, ge=1, le=168)
+    status: Optional[str] = None
+
+
+class NoticiaPatch(BaseModel):
+    titulo: Optional[str] = None
+    corpo: Optional[str] = None
+    resumo: Optional[str] = None
+    status: Optional[str] = None
+
+
+class ConfiguracoesPatch(BaseModel):
+    nvidia_api_key: Optional[str] = None
+    nvidia_base_url: Optional[str] = None
+    nvidia_model: Optional[str] = None
+    google_api_key: Optional[str] = None
+    google_base_url: Optional[str] = None
+    google_model: Optional[str] = None
+    llm_fallback_ordem: Optional[str] = None
+    supabase_url: Optional[str] = None
+    supabase_service_role_key: Optional[str] = None
+    db_backend: Optional[str] = None
+    scheduler_ativo: Optional[bool] = None
+    intervalo_padrao_horas: Optional[int] = Field(default=None, ge=1, le=168)
+
+
+class LlmTestIn(BaseModel):
+    provider: str  # nvidia | google
+
+
+class BlogOut(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    nome: str
+    tema: str
+    regiao: str
+    fontes_rss: List[str]
+    estilo_editorial: str
+    frequencia_horas: int
+    status: str
+    created_at: datetime

package/backend/core/config.py

@@ -1 +1,42 @@
-"""Configuração de runtime do PandaNews (Fase 1): .env, caminhos e constantes."""
+"""Configuração de runtime do PandaNews.
+
+Resolve a raiz estável do runtime (mesma lógica do CLI em Node):
+PANDANEWS_HOME -> ~/.pandanews. Carrega .env quando presente.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except Exception:  # noqa: S110 - .env é opcional
+    pass
+
+
+def resolve_home() -> Path:
+    env = os.environ.get("PANDANEWS_HOME")
+    if env:
+        return Path(env).expanduser().resolve()
+    return Path.home() / ".pandanews"
+
+
+HOME = resolve_home()
+DATA_DIR = HOME / "data"
+IMAGES_DIR = DATA_DIR / "imagens"
+DB_PATH = DATA_DIR / "pandanews.db"
+DB_URL = os.environ.get("PANDANEWS_DB_URL", f"sqlite:///{DB_PATH}")
+
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+SUPABASE_SERVICE_ROLE_KEY = os.environ.get("SUPABASE_SERVICE_ROLE_KEY", "")
+
+DEFAULT_LLM_BASE_URLS = {
+    "nvidia": "https://integrate.api.nvidia.com/v1",
+    "google": "https://generativelanguage.googleapis.com/v1beta/openai",
+}
+DEFAULT_LLM_MODELS = {
+    "nvidia": "meta/llama-3.3-70b-instruct",
+    "google": "gemini-3.8-flash",
+}

package/backend/core/database.py

@@ -1,6 +1,88 @@
-"""Camada de dados do PandaNews (Fase 1).
+"""Camada de dados do PandaNews.
 
-SQLite local por padrão (data/pandanews.db) via SQLAlchemy 2.0, com detecção
-automática de Supabase quando SUPABASE_URL e SUPABASE_SERVICE_ROLE_KEY estão
-definidas no ambiente. Tabelas: blogs, noticias, configuracoes, logs.
+SQLite local por padrão (data/pandanews.db) via SQLAlchemy 2.0. Supabase é
+detectado via SUPABASE_URL/SUPABASE_SERVICE_ROLE_KEY (integração completa na
+Fase 6). Tabelas: blogs, noticias, configuracoes, logs.
 """
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from sqlalchemy import ForeignKey, String, Text, create_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, sessionmaker
+
+from backend.core.config import DB_PATH, DB_URL
+
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+_engine_kwargs: dict = {}
+if DB_URL.startswith("sqlite"):
+    _engine_kwargs["connect_args"] = {"check_same_thread": False}
+engine = create_engine(DB_URL, **_engine_kwargs)
+SessionLocal = sessionmaker(bind=engine, autoflush=False, expire_on_commit=False)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class Blog(Base):
+    __tablename__ = "blogs"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    nome: Mapped[str] = mapped_column(String(200))
+    tema: Mapped[str] = mapped_column(String(50), default="geral")
+    regiao: Mapped[str] = mapped_column(String(100), default="Brasil")
+    fontes_rss: Mapped[str] = mapped_column(Text, default="[]")  # JSON list
+    estilo_editorial: Mapped[str] = mapped_column(Text, default="")
+    frequencia_horas: Mapped[int] = mapped_column(default=6)
+    status: Mapped[str] = mapped_column(String(20), default="ativo")  # ativo | pausado
+    created_at: Mapped[datetime] = mapped_column(default=_now)
+
+
+class Noticia(Base):
+    __tablename__ = "noticias"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    blog_id: Mapped[int] = mapped_column(ForeignKey("blogs.id"), index=True)
+    titulo: Mapped[str] = mapped_column(String(300), default="")
+    corpo: Mapped[str] = mapped_column(Text, default="")
+    resumo: Mapped[str] = mapped_column(Text, default="")
+    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="")
+    created_at: Mapped[datetime] = mapped_column(default=_now, index=True)
+
+
+class Configuracao(Base):
+    __tablename__ = "configuracoes"
+
+    chave: Mapped[str] = mapped_column(String(100), primary_key=True)
+    valor: Mapped[str] = mapped_column(Text, default="")
+
+
+class Log(Base):
+    __tablename__ = "logs"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    blog_id: Mapped[int | None] = mapped_column(ForeignKey("blogs.id"), nullable=True, index=True)
+    etapa: Mapped[str] = mapped_column(String(50), index=True)
+    status: Mapped[str] = mapped_column(String(20), index=True)  # sucesso | erro
+    mensagem: Mapped[str] = mapped_column(Text, default="")
+    created_at: Mapped[datetime] = mapped_column(default=_now, index=True)
+
+
+def init_db() -> None:
+    Base.metadata.create_all(bind=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()