@danhachuel/prodmaker 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -3,6 +3,45 @@
 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.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.**
+- **Vendas funcionais:** tabela com cards (vendas aprovadas, receita, comissão, conversões
+  pendentes), adição manual, **importação CSV** (colunas em ordem livre + upload de arquivo),
+  exclusão e filtro por status de conversão.
+- **Webhooks de venda públicos:** `POST /api/webhook/sale/{hotmart|clickbank|digistore24|
+  kiify|cakto}` com parser **tolerante** (percorre o JSON procurando valor, comissão, e-mail,
+  transação, GCLID, produto e status — cada plataforma usa nomes diferentes; aceita JSON e form).
+  Página lista as URLs prontas para copiar no postback de cada plataforma.
+- **Matching por GCLID:** ao registrar venda com GCLID, o sistema cruza com a visita
+  correspondente na tabela `visitas` (página, IP, origem) e marca 🎯 no GCLID rastreado.
+- **Conversões offline (GCLID):** enxuta implementação REST `uploadClickConversions`
+  (`services/gads.py`): refresh token OAuth → POST Google Ads API (versão configurável,
+  default v22); upload individual ou **em lote** das pendentes; status por venda
+  (pendente/enviada/erro) com erro atribuído; exige Google Ads completo em Chaves de API
+  (developer token, client, refresh token, customer_id e **conversion_action**).
+- Nova tabela `vendas` (com índices em gclid/created_at). Sem novas dependências Python
+  (upload via httpx já incluso).
+
 ## 0.1.07 — 2026-10-27
 
 - **Código de Ativação Mestre:** o login local agora valida o código de verdade.

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/vendas.py

@@ -0,0 +1,167 @@
+import json
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from ..services import gads, vendas
+from ..services.database import get_db, now_str, row_to_dict
+from ..services.llm import LLMError
+
+router = APIRouter(prefix="/api", tags=["vendas"])
+
+WEBHOOK_FONTES = ("hotmart", "clickbank", "digistore24", "kiify", "cakto")
+
+
+class VendaBody(BaseModel):
+    produto_nome: str = ""
+    produto_id: int | None = None
+    valor: float = 0
+    comissao: float = 0
+    gclid: str = ""
+    comprador_email: str = ""
+    transacao_id: str = ""
+
+
+class CsvBody(BaseModel):
+    csv: str
+
+
+# ---------------------------------------------------------------------------
+# Vendas
+# ---------------------------------------------------------------------------
+
+
+@router.get("/vendas")
+def list_vendas():
+    return vendas.list_vendas()
+
+
+@router.get("/vendas/resumo")
+def resumo_vendas():
+    return vendas.resumo()
+
+
+@router.post("/vendas")
+def create_venda(body: VendaBody):
+    if not body.produto_nome.strip():
+        raise HTTPException(status_code=400, detail="Informe o nome do produto.")
+    return vendas.registrar_venda(
+        {
+            "fonte": "manual",
+            "produto_id": body.produto_id,
+            "produto_nome": body.produto_nome.strip(),
+            "valor": body.valor,
+            "comissao": body.comissao or round(body.valor * 0.5, 2),
+            "gclid": body.gclid.strip(),
+            "comprador_email": body.comprador_email.strip(),
+            "transacao_id": body.transacao_id.strip(),
+            "status": "aprovada",
+        }
+    )
+
+
+@router.delete("/vendas/{venda_id}")
+def delete_venda(venda_id: int):
+    vendas.delete_venda(venda_id)
+    return {"ok": True}
+
+
+@router.post("/vendas/csv")
+def importar_csv(body: CsvBody):
+    if not body.csv.strip():
+        raise HTTPException(status_code=400, detail="CSV vazio.")
+    try:
+        return vendas.importar_csv(body.csv)
+    except LLMError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Conversões GCLID (upload offline ao Google Ads)
+# ---------------------------------------------------------------------------
+
+
+@router.post("/vendas/{venda_id}/conversao")
+def upload_conversao(venda_id: int):
+    venda = vendas.get_venda(venda_id)
+    if venda["conversao_status"] == "enviada":
+        raise HTTPException(status_code=400, detail="Conversão desta venda já foi enviada.")
+    try:
+        resultado = gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+    except LLMError as exc:
+        vendas.marcar_conversao(venda_id, "erro", str(exc))
+        raise HTTPException(status_code=400, detail=str(exc))
+    vendas.marcar_conversao(venda_id, "enviada")
+    return {"ok": True, "venda": vendas.get_venda(venda_id), "resultado": resultado}
+
+
+@router.post("/vendas/conversoes/upload")
+def upload_conversoes_pendentes():
+    """Envia todas as vendas aprovadas com GCLID cuja conversão ainda está pendente."""
+    enviadas = []
+    erros = []
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT * FROM vendas WHERE status = 'aprovada' AND gclid != '' AND conversao_status != 'enviada' ORDER BY id"
+        ).fetchall()
+    for row in rows:
+        venda = row_to_dict(row)
+        try:
+            gads.upload_conversao(venda["gclid"], venda["valor"], venda["created_at"])
+            vendas.marcar_conversao(venda["id"], "enviada")
+            enviadas.append(venda["id"])
+        except LLMError as exc:
+            vendas.marcar_conversao(venda["id"], "erro", str(exc))
+            erros.append(f"#{venda['id']}: {exc}")
+    return {"enviadas": enviadas, "erros": erros}
+
+
+# ---------------------------------------------------------------------------
+# Webhooks de vendas (públicos — POST das plataformas de afiliados)
+# ---------------------------------------------------------------------------
+
+
+@router.options("/webhook/sale/{fonte}")
+def webhook_options(fonte: str):
+    return Response(
+        status_code=204,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "*",
+        },
+    )
+
+
+@router.post("/webhook/sale/{fonte}")
+async def webhook_sale(fonte: str, request: Request):
+    fonte = fonte.lower()
+    if fonte not in WEBHOOK_FONTES:
+        raise HTTPException(status_code=404, detail=f"Fonte desconhecida. Suportadas: {', '.join(WEBHOOK_FONTES)}")
+    raw = await request.body()
+    payload = None
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, dict):
+            payload = parsed
+    except Exception:
+        pass
+    if payload is None:
+        # Plataformas que postam em application/x-www-form-urlencoded
+        from urllib.parse import parse_qs
+
+        form = parse_qs(raw.decode("utf-8", errors="replace"))
+        payload = {key: values[0] if len(values) == 1 else values for key, values in form.items()}
+    if not payload:
+        raise HTTPException(status_code=400, detail="Payload vazio ou não reconhecido (envie JSON ou form-urlencoded).")
+    try:
+        data = vendas.parse_webhook(fonte, payload)
+    except Exception as exc:  # noqa: BLE001
+        raise HTTPException(status_code=400, detail=f"Payload não processado: {exc}")
+    venda = vendas.registrar_venda(data)
+    return Response(
+        content=json.dumps({"ok": True, "id": venda["id"]}, ensure_ascii=False),
+        media_type="application/json",
+        headers={"Access-Control-Allow-Origin": "*"},
+    )

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.07"
+APP_VERSION = "0.1.09"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -30,12 +30,16 @@ from .api import llm as llm_router  # noqa: E402
 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
 
 app.include_router(llm_router.router)
 app.include_router(infoprodutos_router.router)
 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)
 
 ensure_db()
 
@@ -242,7 +246,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.7"}
+    return {"version": APP_VERSION, "canonical": "0.1.9"}
 
 
 @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"]}