@danhachuel/prodmaker 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.**

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/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.09"
 COOKIE_NAME = "prodmaker_session"
 SESSION_DAYS = 30
 MASTER_ALIAS = "admin"
@@ -31,6 +31,7 @@ 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)
@@ -38,6 +39,7 @@ 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()
 
@@ -244,7 +246,7 @@ def health():
 
 @app.get("/api/version")
 def version():
-    return {"version": APP_VERSION, "canonical": "0.1.8"}
+    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"]}

package/app/services/campaigns.py

@@ -0,0 +1,166 @@
+"""AdsCreator — construtor de planos de campanha (defaults do seed + produto vinculado)."""
+import json
+from pathlib import Path
+
+from .database import get_db, now_str, row_to_dict
+from .llm import LLMError
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+PLATAFORMAS = ("google", "meta", "tiktok")
+
+
+def _defaults(plataforma: str) -> dict:
+    aliases = {"google": "google", "meta": "meta", "tiktok": "tiktok"}
+    path = SEED_DIR / "campaign-defaults" / f"{aliases[plataforma]}.json"
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {}
+
+
+def construir(produto: dict, plataforma: str, form: dict) -> dict:
+    """Monta o plano da campanha com defaults do seed + dados do produto."""
+    if plataforma not in PLATAFORMAS:
+        raise LLMError(f"Plataforma inválida: {plataforma}. Use: google, meta, tiktok.")
+    comissao = float(produto.get("comissao") or 0)
+    preco = float(produto.get("preco") or 0)
+    receita = comissao or preco * 0.5
+    defaults = _defaults(plataforma)
+
+    if plataforma == "google":
+        cpa_alvo = round(receita * 0.7, 2) if receita else 120.0
+        orcamento = float(form.get("orcamento_diario") or 110)
+        plano = {
+            "rede": "Pesquisa (Search)",
+            "objetivo": "Vendas — conversões",
+            "lance": f"Manual CPC com lance = CPA alvo (R$ {cpa_alvo}) — troque para CPA automático quando a conversão estiver ativa",
+            "cpa_alvo": cpa_alvo,
+            "orcamento_diario": orcamento,
+            "localizacao": "Presença (apenas): Estados Unidos, Canadá, Austrália, Reino Unido",
+            "idiomas": "Inglês e Francês",
+            "correspondencia": "frase",
+            "anuncio": defaults.get("anuncio", {}),
+        }
+    elif plataforma == "meta":
+        ticket = preco or (receita / 0.5 if receita else 0)
+        criativos = max(5, int(form.get("quantidade_criativos") or 5))
+        orcamento = round(criativos * (ticket / 2), 2) if ticket else 300.0
+        plano = {
+            "estrutura": f"1 campanha → 1 conjunto → {criativos} criativos",
+            "objetivo": "Vendas (Conversões)",
+            "publico": "Aberto + Advantage+",
+            "orcamento_diario": orcamento,
+            "regra_budget": "criativos × metade do ticket",
+            "criativos": criativos,
+        }
+    else:
+        plano = {
+            "formato": "Vídeo vertical 9:16, 15–30s, estilo UGC",
+            "objetivo": "Conversões",
+            "publico": "Idade 18–45 (EUA/UK/CA/AU)",
+            "orcamento_diario": float(form.get("orcamento_diario") or 15),
+            "moeda": "USD",
+            "teste": "US$10–20/dia por criativo; escala US$50–100/dia no vencedor",
+        }
+
+    positivas = form.get("keywords") or []
+    negativas = form.get("negativas") or []
+    criativos = form.get("criativos") or []
+    return {
+        "plataforma": plataforma,
+        "nome": form.get("nome") or f"{produto.get('nome') or 'Produto'} — {plataforma.title()}",
+        "produto_id": produto.get("id"),
+        "cpa_alvo": float(plano.get("cpa_alvo") or 0),
+        "orcamento_diario": float(plano.get("orcamento_diario") or 0),
+        "keywords": positivas,
+        "negativas": negativas,
+        "criativos": criativos,
+        "plano": plano,
+        "manual": plataforma == "tiktok",
+    }
+
+
+def salvar(campanha: dict) -> dict:
+    timestamp = now_str()
+    with get_db() as conn:
+        cursor = conn.execute(
+            "INSERT INTO campanhas (produto_id, plataforma, nome, objetivo, cpa_alvo, orcamento_diario, keywords_json, negativas_json, criativos_json, plano_json, status, created_at, updated_at) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'rascunho', ?, ?)",
+            (
+                campanha.get("produto_id"),
+                campanha["plataforma"],
+                campanha["nome"],
+                json.dumps(campanha["plano"].get("objetivo", ""), ensure_ascii=False),
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                timestamp,
+                timestamp,
+            ),
+        )
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return row_to_dict(row)
+
+
+def listar(produto_id: int | None = None) -> list[dict]:
+    query = "SELECT * FROM campanhas"
+    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()
+    return [row_to_dict(row) for row in rows]
+
+
+def get(campanha_id: int) -> dict:
+    with get_db() as conn:
+        row = conn.execute("SELECT * FROM campanhas WHERE id = ?", (campanha_id,)).fetchone()
+    if not row:
+        raise LLMError("Campanha não encontrada.")
+    record = row_to_dict(row)
+    for field in ("keywords_json", "negativas_json", "criativos_json", "plano_json", "resultado_json"):
+        if record.get(field):
+            try:
+                record[field.replace("_json", "")] = json.loads(record[field])
+            except Exception:  # noqa: BLE001
+                record[field.replace("_json", "")] = record[field]
+    return record
+
+
+def remover(campanha_id: int) -> None:
+    with get_db() as conn:
+        cursor = conn.execute("DELETE FROM campanhas WHERE id = ?", (campanha_id,))
+        if cursor.rowcount == 0:
+            raise LLMError("Campanha não encontrada.")
+
+
+def marcar_publicada(campanha_id: int, resultado: dict, status: str = "publicada", erro: str = "") -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET status = ?, resultado_json = ?, erro = ?, updated_at = ? WHERE id = ?",
+            (status, json.dumps(resultado, ensure_ascii=False), erro[:2000], now_str(), campanha_id),
+        )
+    return get(campanha_id)
+
+
+def atualizar(campanha_id: int, campanha: dict) -> dict:
+    with get_db() as conn:
+        conn.execute(
+            "UPDATE campanhas SET nome = ?, cpa_alvo = ?, orcamento_diario = ?, keywords_json = ?, negativas_json = ?, criativos_json = ?, plano_json = ?, updated_at = ? WHERE id = ?",
+            (
+                campanha["nome"],
+                campanha.get("cpa_alvo") or 0,
+                campanha.get("orcamento_diario") or 0,
+                json.dumps(campanha["keywords"], ensure_ascii=False),
+                json.dumps(campanha["negativas"], ensure_ascii=False),
+                json.dumps(campanha["criativos"], ensure_ascii=False),
+                json.dumps(campanha["plano"], ensure_ascii=False),
+                now_str(),
+                campanha_id,
+            ),
+        )
+    return get(campanha_id)

package/app/services/database.py

@@ -124,6 +124,42 @@ def ensure_db() -> None:
         conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_gclid ON vendas (gclid)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_vendas_created ON vendas (created_at)")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_visitas_gclid ON visitas (gclid)")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS palavras (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                produto_nome TEXT NOT NULL DEFAULT '',
+                tipo TEXT NOT NULL DEFAULT 'positiva',
+                texto TEXT NOT NULL,
+                correspondencia TEXT NOT NULL DEFAULT 'frase',
+                origem TEXT NOT NULL DEFAULT 'ia',
+                created_at TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS campanhas (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                produto_id INTEGER,
+                plataforma TEXT NOT NULL DEFAULT 'google',
+                nome TEXT NOT NULL,
+                objetivo TEXT NOT NULL DEFAULT '',
+                cpa_alvo REAL NOT NULL DEFAULT 0,
+                orcamento_diario REAL NOT NULL DEFAULT 0,
+                keywords_json TEXT NOT NULL DEFAULT '[]',
+                negativas_json TEXT NOT NULL DEFAULT '[]',
+                criativos_json TEXT NOT NULL DEFAULT '[]',
+                plano_json TEXT NOT NULL DEFAULT '',
+                status TEXT NOT NULL DEFAULT 'rascunho',
+                resultado_json TEXT NOT NULL DEFAULT '',
+                erro TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
         columns = [row["name"] for row in conn.execute("PRAGMA table_info(produtos)")]
         if "analysis" not in columns:
             conn.execute("ALTER TABLE produtos ADD COLUMN analysis TEXT NOT NULL DEFAULT ''")