@danhachuel/prodmaker 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 Todas as versões seguem a etiqueta visual `MAJOR.MINOR.PATCH` com patch de dois dígitos
 (o registry NPM normaliza `0.1.00` → `0.1.0`).
 
+## 0.1.10 — 2026-10-30
+
+- **Parte 8 — AdsBot (Lançamento Assistido) + Dashboard real + Notificações (adsNotify).**
+- **AdsBot:** wizard de 6 etapas (Produto → Página → Publicar → Campanhas → Tracking →
+  Conclusão) com progresso salvo no banco e retomável; marcação de etapas concluídas;
+  **Relatório de Lançamento** (produto + resumo da análise IA, páginas vinculadas com URLs
+  públicas, campanhas com CPA/orçamento e o checklist final do seed).
+- **Dashboard com dados reais:** conversões, receita, comissão, visitas, produtos, páginas,
+  campanhas e infoprodutos; banner do lançamento em andamento ("faltam X passos" — efeito
+  meta); últimas vendas e últimas páginas. ROAS explicitamente ausente até haver registro
+  de investimento (nunca inventado).
+- **Notificações (adsNotify):** toggles por evento (venda recebida, campanha publicada,
+  página publicada, infoproduto gerado), canais apprise por URL (Telegram entra
+  automaticamente quando Bot Token + Chat ID estão em Chaves de API), teste de envio e
+  histórico local com status/erro. Hooks disparados nos fluxos reais — falha de envio
+  nunca quebra a operação principal.
+- Novas tabelas: `lancamentos`, `notificacoes`. Novos endpoints: `/api/lancamentos/*`,
+  `/api/notificacoes/*`, `/api/dashboard`.
+
+## 0.1.09 — 2026-10-30
+
+- **Parte 7 — AdsWords & AdsCreator (palavras-chave e campanhas).**
+- **AdsWords funcional:** geração de palavras-chave + negativas por IA (prompt do seed,
+  negativas padrão aplicadas automaticamente), listas por produto (positivas/negativas com
+  origem IA/manual), adição manual, remoção e cópia.
+- **Gerador de criativos por IA** (fórmula gancho 3s + promessa + prova + CTA) reutilizado
+  pelo AdsCreator (Google/Meta/TikTok).
+- **AdsCreator — construtor de campanhas:** cards por plataforma, formulário que puxa
+  produto vinculado (comissão → **CPA alvo 70%** no Google; regra criativos × ½ ticket no
+  Meta; teste US$10–20 no TikTok), defaults do seed versionados, salva **rascunho** com
+  plano completo (review modal com JSON do plano + palavras + criativos).
+- **Publicação real (best-effort):** Google Ads via cadeia de mutates REST (orçamento →
+  campanha PAUSADA → grupo → keywords frase + negativas → anúncio RSA), Meta Ads via
+  Marketing API (campanha → conjunto → criativo → anúncio, POSTs simples) e TikTok como
+  plano manual guiado. Tudo criado **PAUSADO para revisão**; erros por etapa com attribution;
+  status por campanha (rascunho/publicada/erro).
+- Novas tabelas: `palavras`, `campanhas`.
+
 ## 0.1.08 — 2026-10-30
 
 - **Parte 6 — Minhas Vendas & Conversões GCLID.**

package/app/api/ads.py

@@ -0,0 +1,155 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import adswords, campaigns, publish_ads
+from ..services.database import get_db, row_to_dict
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api", tags=["ads"])
+
+
+def _produto_or_none(produto_id: int | None) -> dict:
+    if not produto_id:
+        return {"id": None, "nome": "Produto", "nicho": "", "plataforma": ""}
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM produtos WHERE id = ?", (produto_id,)).fetchone()
+    return row_to_dict(row) if row else {"id": produto_id, "nome": "Produto", "nicho": "", "plataforma": ""}
+
+
+class KeywordsBody(BaseModel):
+    produto_id: int | None = None
+
+
+class PalavraBody(BaseModel):
+    produto_id: int | None = None
+    tipo: str = "positiva"
+    texto: str
+    correspondencia: str = "frase"
+
+
+class CriativosBody(BaseModel):
+    produto_id: int | None = None
+    quantidade: int = 3
+
+
+class CampanhaBody(BaseModel):
+    produto_id: int | None = None
+    plataforma: str = "google"
+    nome: str = ""
+    orcamento_diario: float | None = None
+    quantidade_criativos: int | None = None
+    keywords: list = []
+    negativas: list = []
+    criativos: list = []
+
+
+# ---------------------------------------------------------------------------
+# AdsWords
+# ---------------------------------------------------------------------------
+
+
+@router.post("/adswords/gerar")
+def adswords_gerar(body: KeywordsBody):
+    produto = _produto_or_none(body.produto_id)
+    try:
+        return adswords.gerar(produto)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.get("/adswords")
+def adswords_listar(produto_id: int | None = None):
+    return adswords.listar(produto_id)
+
+
+@router.post("/adswords")
+def adswords_adicionar(body: PalavraBody):
+    if not body.texto.strip():
+        raise HTTPException(status_code=400, detail="Informe a palavra.")
+    if body.tipo not in ("positiva", "negativa"):
+        raise HTTPException(status_code=400, detail="Tipo inválido.")
+    return adswords.adicionar_manual(_produto_or_none(body.produto_id), body.tipo, body.texto, body.correspondencia)
+
+
+@router.delete("/adswords/{palavra_id}")
+def adswords_remover(palavra_id: int):
+    try:
+        adswords.remover(palavra_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}
+
+
+@router.post("/criativos/gerar")
+def criativos_gerar(body: CriativosBody):
+    produto = _produto_or_none(body.produto_id)
+    try:
+        return adswords.gerar_criativos(produto, body.quantidade)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Campanhas (AdsCreator)
+# ---------------------------------------------------------------------------
+
+
+@router.get("/campanhas")
+def campanhas_listar(produto_id: int | None = None):
+    return campaigns.listar(produto_id)
+
+
+@router.post("/campanhas")
+def campanhas_criar(body: CampanhaBody):
+    produto = _produto_or_none(body.produto_id)
+    try:
+        plano = campaigns.construir(produto, body.plataforma, body.model_dump())
+        if body.nome.strip():
+            plano["nome"] = body.nome.strip()
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return campaigns.salvar(plano)
+
+
+@router.get("/campanhas/{campanha_id}")
+def campanhas_get(campanha_id: int):
+    try:
+        return campaigns.get(campanha_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.delete("/campanhas/{campanha_id}")
+def campanhas_remover(campanha_id: int):
+    try:
+        campaigns.remover(campanha_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True}
+
+
+@router.post("/campanhas/{campanha_id}/publicar")
+def campanhas_publicar(campanha_id: int):
+    try:
+        campanha = campaigns.get(campanha_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    if campanha["status"] == "publicada":
+        raise HTTPException(status_code=400, detail="Campanha já publicada.")
+    plataforma = campanha["plataforma"]
+    try:
+        if plataforma == "google":
+            resultado = publish_ads.publicar_google(campanha)
+        elif plataforma == "meta":
+            resultado = publish_ads.publicar_meta(campanha)
+        else:
+            resultado = {
+                "plataforma": "tiktok",
+                "etapas": [{"etapa": "manual", "observacao": "TikTok: siga o checklist do plano (formato 9:16 UGC) e crie manualmente no TikTok Ads Manager."}],
+                "observacao": "Plano manual — crie manualmente no TikTok Ads Manager.",
+            }
+    except LLMError as exc:
+        campaigns.marcar_publicada(campanha_id, {}, status="erro", erro=str(exc))
+        raise HTTPException(status_code=400, detail=str(exc))
+    campanha = campaigns.marcar_publicada(campanha_id, resultado)
+    return campanha

package/app/api/dashboard.py

@@ -0,0 +1,67 @@
+"""Dashboard — agregação de dados reais de todos os módulos."""
+from fastapi import APIRouter
+
+from ..services.database import get_db
+
+router = APIRouter(prefix="/api/dashboard", tags=["dashboard"])
+
+
+@router.get("")
+def dashboard():
+    with get_db() as conn:
+        produtos = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM produtos").fetchone()["n"],
+            "aprovados": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'aprovado'").fetchone()["n"],
+            "em_analise": conn.execute("SELECT COUNT(*) AS n FROM produtos WHERE status = 'em_analise'").fetchone()["n"],
+        }
+        paginas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM paginas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM paginas WHERE status != 'publicada'").fetchone()["n"],
+        }
+        campanhas = {
+            "total": conn.execute("SELECT COUNT(*) AS n FROM campanhas").fetchone()["n"],
+            "publicadas": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'publicada'").fetchone()["n"],
+            "rascunho": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'rascunho'").fetchone()["n"],
+            "erro": conn.execute("SELECT COUNT(*) AS n FROM campanhas WHERE status = 'erro'").fetchone()["n"],
+        }
+        vendas_row = conn.execute(
+            "SELECT COUNT(*) AS n, COALESCE(SUM(valor),0) AS receita, COALESCE(SUM(comissao),0) AS comissao FROM vendas WHERE status = 'aprovada'"
+        ).fetchone()
+        infoprodutos = {"total": conn.execute("SELECT COUNT(*) AS n FROM infoprodutos").fetchone()["n"]}
+        tracking = {
+            "visitas": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'pageview'").fetchone()["n"],
+            "cliques": conn.execute("SELECT COUNT(*) AS n FROM visitas WHERE event = 'cta_click'").fetchone()["n"],
+            "conversoes_pendentes": conn.execute(
+                "SELECT COUNT(*) AS n FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada'"
+            ).fetchone()["n"],
+        }
+        ultimas_vendas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, produto_nome, valor, fonte, status, created_at FROM vendas ORDER BY id DESC LIMIT 5")
+        ]
+        ultimas_paginas = [
+            {key: row[key] for key in row.keys()}
+            for row in conn.execute("SELECT id, titulo, tipo, status, created_at FROM paginas ORDER BY id DESC LIMIT 5")
+        ]
+
+    from ..services.lancamentos import atual, progresso
+    lancamento_atual = atual()
+    progresso_atual = progresso(lancamento_atual) if lancamento_atual else None
+
+    return {
+        "produtos": produtos,
+        "paginas": paginas,
+        "campanhas": campanhas,
+        "infoprodutos": infoprodutos,
+        "vendas": {
+            "total": vendas_row["n"],
+            "receita": round(vendas_row["receita"], 2),
+            "comissao": round(vendas_row["comissao"], 2),
+        },
+        "tracking": tracking,
+        "ultimas_vendas": ultimas_vendas,
+        "ultimas_paginas": ultimas_paginas,
+        "lancamento": lancamento_atual,
+        "progresso": progresso_atual,
+    }

package/app/api/infoprodutos.py

@@ -88,7 +88,16 @@ def create_infoproduto(body: InfoprodutoBody):
                 (provider, rel_pdf, rel_md, record_id),
             )
             row = conn.execute("SELECT * FROM infoprodutos WHERE id = ?", (record_id,)).fetchone()
-        return row_to_dict(row)
+        record = row_to_dict(row)
+
+        from ..services.notify import notify_event
+
+        notify_event(
+            "infoproduto_gerado",
+            "Infoproduto gerado",
+            f"{record['titulo']} ({record['formato']}) — {record['provider']}",
+        )
+        return record
     except (LLMError, gamma_service.GammaError, RuntimeError) as exc:
         with get_db() as conn:
             conn.execute("DELETE FROM infoprodutos WHERE id = ?", (record_id,))

package/app/api/lancamentos.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import lancamentos
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/lancamentos", tags=["lancamentos"])
+
+
+class IniciarBody(BaseModel):
+    produto_id: int | None = None
+
+
+class EtapaBody(BaseModel):
+    etapa: int
+    dados: dict = {}
+
+
+class ProdutoBody(BaseModel):
+    produto_id: int
+
+
+@router.get("/etapas")
+def etapas():
+    return lancamentos.ETAPAS
+
+
+@router.get("/atual")
+def lancamento_atual():
+    return lancamentos.atual()
+
+
+@router.get("")
+def listar():
+    return lancamentos.listar()
+
+
+@router.post("")
+def iniciar(body: IniciarBody):
+    return lancamentos.iniciar(body.produto_id)
+
+
+@router.post("/{lancamento_id}/etapa")
+def salvar_etapa(lancamento_id: int, body: EtapaBody):
+    try:
+        return lancamentos.salvar_etapa(lancamento_id, body.etapa, body.dados)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/{lancamento_id}/produto")
+def definir_produto(lancamento_id: int, body: ProdutoBody):
+    try:
+        return lancamentos.definir_produto(lancamento_id, body.produto_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/relatorio")
+def relatorio(lancamento_id: int):
+    try:
+        return lancamentos.relatorio(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+
+@router.get("/{lancamento_id}/progresso")
+def progresso(lancamento_id: int):
+    try:
+        record = lancamentos._get_row(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return lancamentos.progresso(record)
+
+
+@router.post("/{lancamento_id}/concluir")
+def concluir(lancamento_id: int):
+    try:
+        return lancamentos.concluir(lancamento_id)
+    except LLMError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))

package/app/api/notificacoes.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..services import notify
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api/notificacoes", tags=["notificacoes"])
+
+
+class ConfigBody(BaseModel):
+    eventos: dict = {}
+    targets: list = []
+
+
+class TesteBody(BaseModel):
+    titulo: str = "Teste ProdMaker"
+    mensagem: str = "Notificação de teste do ProdMaker."
+
+
+@router.get("")
+def config():
+    return notify.listar_config()
+
+
+@router.put("")
+def salvar(body: ConfigBody):
+    return notify.salvar_config(body.eventos, body.targets)
+
+
+@router.get("/historico")
+def historico():
+    return notify.historico()
+
+
+@router.post("/teste")
+def teste(body: TesteBody):
+    try:
+        return notify.enviar("teste", body.titulo, body.mensagem, forcar=True)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))

package/app/api/paginas.py

@@ -130,6 +130,14 @@ def publicar(page_id: int):
         )
     updated = _get_or_404(page_id)
     updated["publish_result"] = result
+
+    from ..services.notify import notify_event
+
+    notify_event(
+        "pagina_publicada",
+        "Página publicada",
+        f"{updated['titulo']} — {result['pages_url']}",
+    )
     return updated
 
 

package/app/main.py

@@ -15,7 +15,7 @@ from .services.database import ensure_db, get_db, now_str, row_to_dict
 from .services.llm import LLMError, analyze_product, list_providers
 from .services.store import PRODMAKER_HOME, STORAGE, STATE, ensure_state_dir, get_master_code, get_settings, save_settings
 
-APP_VERSION = "0.1.08"
+APP_VERSION = "0.1.10"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -31,6 +31,10 @@ from .api import paginas as paginas_router  # noqa: E402
 from .api import dominios as dominios_router  # noqa: E402
 from .api import tracking as tracking_router  # noqa: E402
 from .api import vendas as vendas_router  # noqa: E402
+from .api import ads as ads_router  # noqa: E402
+from .api import lancamentos as lancamentos_router  # noqa: E402
+from .api import notificacoes as notificacoes_router  # noqa: E402
+from .api import dashboard as dashboard_router  # noqa: E402
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
@@ -38,6 +42,10 @@ app.include_router(paginas_router.router)
 app.include_router(dominios_router.router)
 app.include_router(tracking_router.router)
 app.include_router(vendas_router.router)
+app.include_router(ads_router.router)
+app.include_router(lancamentos_router.router)
+app.include_router(notificacoes_router.router)
+app.include_router(dashboard_router.router)
 
 ensure_db()
 
@@ -244,7 +252,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.8"}
+    return {"version": APP_VERSION, "canonical": "0.1.10"}
 
 
 @app.get("/api/settings")

package/app/services/adswords.py

@@ -0,0 +1,158 @@
+"""AdsWords — geração de palavras-chave e negativas por IA + listas por produto."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError, generate
+from .store import STORAGE
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+SEED_NEGATIVAS = SEED_DIR / "negatives" / "google-words.txt"
+
+
+def _seed_negativas() -> list[str]:
+    if SEED_NEGATIVAS.exists():
+        return [line.strip() for line in SEED_NEGATIVAS.read_text(encoding="utf-8").splitlines() if line.strip()]
+    return ["gratis", "download", "torrent", "refund", "scams"]
+
+
+def gerar(produto: dict) -> dict:
+    """Gera palavras-chave e negativas com IA (seed/prompts/keywords.md)."""
+    template_path = SEED_DIR / "prompts" / "keywords.md"
+    template = template_path.read_text(encoding="utf-8") if template_path.exists() else (
+        "Para o produto {NOME_DO_PRODUTO} (nicho {NICHO}) liste palavras-chave de compra e negativas em JSON: "
+        '{"principais":[{"palavra":"","correspondencia":"frase"}],"negativas":[{"palavra":""}]}'
+    )
+    prompt = (
+        template.replace("{NOME_DO_PRODUTO}", produto.get("nome") or "")
+        .replace("{NICHO}", produto.get("nicho") or "")
+        .replace("{PLATAFORMA}", produto.get("plataforma") or "")
+    )
+    result = generate(
+        prompt,
+        system="Você é um especialista em Google Ads. Responda SOMENTE com JSON válido, sem markdown.",
+        max_tokens=2000,
+    )
+    try:
+        parsed = json.loads(_clean_json(result["text"]))
+    except Exception as exc:  # noqa: BLE001
+        raise LLMError(f"Resposta do LLM não trouxe JSON utilizável: {exc}") from exc
+
+    positivas = []
+    for item in parsed.get("principais") or []:
+        text = (item.get("palavra") or "").strip()
+        if text:
+            positivas.append({"texto": text, "correspondencia": item.get("correspondencia") or "frase"})
+    negativas_ia = []
+    for item in parsed.get("negativas") or []:
+        text = (item.get("palavra") or "").strip()
+        if text:
+            negativas_ia.append({"texto": text, "correspondencia": "exata"})
+    for seed_word in _seed_negativas():
+        if not any(n["texto"] == seed_word for n in negativas_ia):
+            negativas_ia.append({"texto": seed_word, "correspondencia": "exata", "seed": True})
+
+    salvar(produto, positivas, negativas_ia, origem="ia")
+    return {"positivas": positivas, "negativas": negativas_ia, "provider": result["provider"]}
+
+
+def _clean_json(text: str) -> str:
+    import re
+
+    cleaned = re.sub(r"```(?:json)?", "", text).strip()
+    match = re.search(r"\{.*\}", cleaned, re.DOTALL)
+    return match.group(0) if match else cleaned
+
+
+def salvar(produto: dict, positivas: list, negativas: list, origem: str = "manual") -> None:
+    timestamp = now_str()
+    with get_db() as conn:
+        for item in positivas:
+            exists = conn.execute(
+                "SELECT id FROM palavras WHERE produto_id = ? AND tipo = 'positiva' AND texto = ?",
+                (produto.get("id"), item["texto"]),
+            ).fetchone()
+            if not exists:
+                conn.execute(
+                    "INSERT INTO palavras (produto_id, produto_nome, tipo, texto, correspondencia, origem, created_at) VALUES (?, ?, 'positiva', ?, ?, ?, ?)",
+                    (produto.get("id"), produto.get("nome") or "", item["texto"], item.get("correspondencia", "frase"), origem, timestamp),
+                )
+        for item in negativas:
+            exists = conn.execute(
+                "SELECT id FROM palavras WHERE produto_id = ? AND tipo = 'negativa' AND texto = ?",
+                (produto.get("id"), item["texto"]),
+            ).fetchone()
+            if not exists:
+                conn.execute(
+                    "INSERT INTO palavras (produto_id, produto_nome, tipo, texto, correspondencia, origem, created_at) VALUES (?, ?, 'negativa', ?, ?, ?, ?)",
+                    (produto.get("id"), produto.get("nome") or "", item["texto"], "exata", origem, timestamp),
+                )
+
+
+def listar(produto_id: int | None = None) -> dict:
+    query = "SELECT * FROM palavras"
+    params: tuple = ()
+    if produto_id:
+        query += " WHERE produto_id = ?"
+        params = (produto_id,)
+    query += " ORDER BY id DESC"
+    with get_db() as conn:
+        rows = conn.execute(query, params).fetchall()
+    items = [row_to_dict(row) for row in rows]
+    return {
+        "positivas": [item for item in items if item["tipo"] == "positiva"],
+        "negativas": [item for item in items if item["tipo"] == "negativa"],
+    }
+
+
+def adicionar_manual(produto: dict, tipo: str, texto: str, correspondencia: str = "frase") -> dict:
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO palavras (produto_id, produto_nome, tipo, texto, correspondencia, origem, created_at) VALUES (?, ?, ?, ?, ?, 'manual', ?)",
+            (produto.get("id"), produto.get("nome") or "", tipo, texto.strip(), correspondencia, timestamp),
+        )
+        row = conn.execute("SELECT * FROM palavras WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+def remover(palavra_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM palavras WHERE id = ?", (palavra_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Palavra não encontrada.")
+
+
+def gerar_criativos(produto: dict, quantidade: int = 3) -> dict:
+    """Gera roteiros de criativos por IA (seed/prompts/criativos.md)."""
+    template_path = SEED_DIR / "prompts" / "criativos.md"
+    template = template_path.read_text(encoding="utf-8") if template_path.exists() else (
+        'Gere {QUANTIDADE} roteiros de criativo para {NOME_DO_PRODUTO} no formato '
+        '{"criativos":[{"gancho_3s":"","roteiro":"","texto_na_tela":"","cta":""}]}'
+    )
+    prompt = (
+        template.replace("{QUANTIDADE}", str(quantidade))
+        .replace("{NOME_DO_PRODUTO}", produto.get("nome") or "")
+        .replace("{DOR}", produto.get("nicho") or "")
+    )
+    result = generate(
+        prompt,
+        system="Você é um copywriter de direct response para tráfego pago. Responda SOMENTE com JSON válido.",
+        max_tokens=3000,
+    )
+    try:
+        parsed = json.loads(_clean_json(result["text"]))
+    except Exception as exc:  # noqa: BLE001
+        raise LLMError(f"Resposta do LLM não trouxe JSON utilizável: {exc}") from exc
+    criativos = parsed.get("criativos") or parsed.get("roteiros") or []
+    normalizados = [
+        {
+            "gancho_3s": item.get("gancho_3s") or "",
+            "roteiro": item.get("roteiro") or "",
+            "texto_na_tela": item.get("texto_na_tela") or "",
+            "cta": item.get("cta") or "Clique no link abaixo e comece agora!",
+        }
+        for item in criativos
+        if isinstance(item, dict)
+    ]
+    return {"criativos": normalizados, "provider": result["provider"]}