@danhachuel/prodmaker 0.1.4 → 0.1.6

package/app/services/pages.py

@@ -0,0 +1,102 @@
+"""Geração de landing pages via LLM — pre-sell (afiliado) e página de vendas (12 seções)."""
+import re
+from pathlib import Path
+
+from .llm import LLMError, generate
+from .store import STORAGE
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+
+
+def _pixel_snippet() -> str:
+    """Pixel do ProdMaker embutido nas páginas geradas (se configurado)."""
+    from .store import get_settings
+
+    settings = get_settings()
+    pixel_url = (((settings.get("api_keys") or {}).get("tracking") or {}).get("pixel_url") or "").strip()
+    if not pixel_url:
+        return ""
+    base = pixel_url.rstrip("/")
+    return (
+        "\n<!-- ProdMaker Pixel -->\n<script>\n"
+        "(function(){\n"
+        f"  var base = \"{base}\";\n"
+        "  var q = new URLSearchParams(window.location.search);\n"
+        "  var params = \"event=pageview&page=\" + encodeURIComponent(location.pathname) +\n"
+        "    \"&ref=\" + encodeURIComponent(document.referrer || \"\") +\n"
+        "    \"&gclid=\" + encodeURIComponent(q.get(\"gclid\") || \"\") +\n"
+        "    \"&utm_source=\" + encodeURIComponent(q.get(\"utm_source\") || \"\") +\n"
+        "    \"&utm_medium=\" + encodeURIComponent(q.get(\"utm_medium\") || \"\") +\n"
+        "    \"&utm_campaign=\" + encodeURIComponent(q.get(\"utm_campaign\") || \"\");\n"
+        "  try { navigator.sendBeacon(base + \"?\" + params); } catch (e) {}\n"
+        "  document.addEventListener(\"click\", function (e) {\n"
+        "    var a = e.target.closest ? e.target.closest(\"a[href]\") : null;\n"
+        "    if (a) { try { navigator.sendBeacon(base + \"?event=cta_click&href=\" + encodeURIComponent(a.href)); } catch (err) {} }\n"
+        "  }, true);\n"
+        "  window.addEventListener(\"beforeunload\", function () {\n"
+        "    try { navigator.sendBeacon(base + \"?event=unload&seconds=\" + Math.round(performance.now() / 1000)); } catch (e) {}\n"
+        "  });\n"
+        "})();\n</script>\n"
+    )
+
+
+def _load_template(nome: str) -> str:
+    path = SEED_DIR / "prompts" / nome
+    return path.read_text(encoding="utf-8") if path.exists() else ""
+
+
+def _fill(template: str, values: dict) -> str:
+    for key, value in values.items():
+        template = template.replace("{" + key + "}", str(value or ""))
+    return template
+
+
+def _ensure_single_html(html: str) -> str:
+    """Extrai o primeiro documento HTML completo da resposta do LLM."""
+    match = re.search(r"<!DOCTYPE html>.*</html>", html, re.DOTALL | re.IGNORECASE)
+    return (match.group(0) if match else html).strip()
+
+
+def gerar_pagina(tipo: str, produto: dict | None, form: dict) -> dict:
+    """Gera o HTML da página. tipo: 'presell' | 'vendas'."""
+    if tipo not in ("presell", "vendas"):
+        raise LLMError("Tipo de página inválido.")
+    produto = produto or {}
+    afiliado = (form.get("afiliado_link") or produto.get("link_afiliado") or "").strip()
+    checkout = (form.get("checkout_link") or afiliado or "#").strip()
+    template = _load_template("pre-sell.md" if tipo == "presell" else "pagina-vendas.md")
+    prompt = _fill(
+        template,
+        {
+            "NOME_DO_PRODUTO": form.get("titulo") or produto.get("nome") or "Produto",
+            "NOME": produto.get("nome") or form.get("titulo") or "Produto",
+            "RESUMO": produto.get("analysis") and "ver análise" or form.get("prompt") or "",
+            "PRECO": produto.get("preco") or "",
+            "AVATAR": form.get("avatar") or "",
+            "RESULTADO": form.get("resultado") or "",
+            "TEMPO": form.get("tempo") or "poucos dias",
+            "DOR": form.get("dor") or produto.get("nicho") or "",
+            "LINK_AFILIADO": afiliado or checkout,
+            "LINK_CHECKOUT": checkout,
+            "PIXEL_SNIPPET": _pixel_snippet(),
+        },
+    )
+    idioma = form.get("idioma") or "Português"
+    system = (
+        f"Escreva TODO o conteúdo da página em {idioma}. "
+        "Você é um copywriter de direct response especialista em páginas de alta conversão. "
+        "Retorne APENAS o HTML completo em um único arquivo (CSS e JS embutidos), sem comentários fora do código."
+    )
+    result = generate(prompt, system=system, max_tokens=8000)
+    html = _ensure_single_html(result["text"])
+    if "</html>" not in html.lower():
+        html = f"<!DOCTYPE html><html lang=\"pt-BR\"><head><meta charset=\"UTF-8\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"><title>{form.get('titulo') or 'Página'}</title></head><body>{html}</body></html>"
+    return {"html": html, "provider": result["provider"]}
+
+
+def salvar_html(page_id: int, html: str) -> Path:
+    folder = STORAGE / "pages" / str(page_id)
+    folder.mkdir(parents=True, exist_ok=True)
+    path = folder / "index.html"
+    path.write_text(html, encoding="utf-8")
+    return path

package/app/services/publish.py

@@ -0,0 +1,74 @@
+"""Publicação de páginas — GitHub Contents API (commit do HTML no repositório de páginas).
+
+A implantação no Cloudflare Pages acontece automaticamente quando o repositório
+está conectado a um projeto do Cloudflare Pages (conexão única, feita no painel).
+"""
+import base64
+
+import httpx
+
+from .llm import LLMError
+
+GITHUB_API = "https://api.github.com"
+
+
+def _github_config() -> tuple[str, str]:
+    from .store import get_settings
+
+    keys = (get_settings().get("api_keys") or {}).get("github") or {}
+    token = (keys.get("token") or "").strip()
+    repo = (keys.get("repo") or "").strip()
+    return token, repo
+
+
+def publicar_pagina(page_id: int, titulo: str, html: str) -> dict:
+    token, repo = _github_config()
+    if not token or not repo:
+        raise LLMError(
+            "Publicação requer GitHub configurado (token PAT + repositório) em Chaves de API. "
+            "Alternativa sem publicar: use o download do HTML e hospede manualmente."
+        )
+    owner, _, repo_name = repo.partition("/")
+    if not repo_name:
+        raise LLMError("Repositório inválido — use o formato usuario/repositorio.")
+    slug = "".join(char if char.isalnum() or char in "-" else "-" for char in titulo.lower())[:40].strip("-") or f"pagina-{page_id}"
+    path = f"paginas/{page_id}-{slug}.html"
+    content_bytes = base64.b64encode(html.encode("utf-8")).decode()
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    try:
+        with httpx.Client(timeout=60.0) as client:
+            existing = client.get(f"{GITHUB_API}/repos/{owner}/{repo_name}/contents/{path}", headers=headers, params={"ref": "main"})
+            sha = None
+            if existing.status_code == 200:
+                sha = (existing.json() or {}).get("sha")
+            elif existing.status_code not in (404, 409):
+                raise LLMError(f"GitHub respondeu {existing.status_code} ao consultar o arquivo: {existing.text[:200]}")
+
+            body = {
+                "message": f"ProdMaker: página {page_id} — {titulo}",
+                "content": content_bytes,
+                "branch": "main",
+            }
+            if sha:
+                body["sha"] = sha
+            put = client.put(f"{GITHUB_API}/repos/{owner}/{repo_name}/contents/{path}", headers=headers, json=body)
+            if put.status_code not in (200, 201):
+                raise LLMError(f"GitHub rejeitou o commit ({put.status_code}): {put.text[:300]}")
+            commit = (put.json() or {}).get("commit") or {}
+            commit_url = (put.json() or {}).get("content", {}).get("html_url") or (commit.get("html_url") or "")
+    except httpx.HTTPError as exc:
+        raise LLMError(f"Falha de conexão com o GitHub: {exc}") from exc
+
+    pages_url = f"https://{owner}.github.io/{repo_name}/{path}"
+    return {
+        "ok": True,
+        "path": path,
+        "commit_url": commit_url,
+        "pages_url": pages_url,
+        "aviso": "Se o repositório estiver conectado a um projeto no Cloudflare Pages, o deploy acontece automaticamente.",
+    }

package/app/services/tracking.py

@@ -0,0 +1,218 @@
+"""AdsTracking — agregações do pixel próprio (tabela visitas) + parser de User-Agent."""
+import hashlib
+import re
+from datetime import datetime, timedelta
+
+from .database import get_db
+from .store import get_settings
+
+DRENAGEM_MIN_CLIQUE = 4  # IP com >= N cliques em CTA entra no alerta de drenagem
+
+
+def parse_user_agent(ua: str) -> dict:
+    ua = ua or ""
+    low = ua.lower()
+    if "ipad" in low or "tablet" in low:
+        device = "Tablet"
+    elif "mobile" in low or "iphone" in low or "android" in low:
+        device = "Smartphone"
+    elif ua:
+        device = "Computador"
+    else:
+        device = "—"
+
+    if "windows" in low:
+        os_name = "Windows"
+    elif "iphone" in low or "ipad" in low or " mac" in low or low.startswith("mac"):
+        os_name = "iOS" if ("iphone" in low or "ipad" in low) else "macOS"
+    elif "android" in low:
+        os_name = "Android"
+    elif "mac os" in low:
+        os_name = "macOS"
+    elif "linux" in low:
+        os_name = "Linux"
+    else:
+        os_name = "—"
+
+    if "edg/" in low or "edge" in low:
+        browser = "Edge"
+    elif "opr/" in low or "opera" in low:
+        browser = "Opera"
+    elif "chrome" in low or "crios" in low:
+        browser = "Chrome"
+    elif "firefox" in low or "fxios" in low:
+        browser = "Firefox"
+    elif "safari" in low:
+        browser = "Safari"
+    else:
+        browser = "—"
+    return {"device": device, "os": os_name, "browser": browser}
+
+
+def visitor_id(ip: str) -> str:
+    return hashlib.sha256((ip or "").encode()).hexdigest()[:12].lower()
+
+
+def _since_clause(days: int) -> str:
+    start = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
+    return start
+
+
+def _domain(url: str) -> str:
+    match = re.match(r"https?://([^/]+)", url or "")
+    return match.group(1).replace("www.", "") if match else (url or "")
+
+
+def dashboard(days: int = 90) -> dict:
+    start = _since_clause(days)
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT event, page, gclid, utm_source, utm_medium, utm_campaign, ref, ip, user_agent, extra, created_at "
+            "FROM visitas WHERE created_at >= ? ORDER BY created_at DESC",
+            (start,),
+        ).fetchall()
+    rows = [dict(row) for row in rows]
+    pageviews = [r for r in rows if r["event"] == "pageview"]
+    cliques = [r for r in rows if r["event"] == "cta_click"]
+
+    # --- Métricas ---
+    ips_unicos = {r["ip"] for r in pageviews if r["ip"]}
+    resumo = {
+        "visitas": len(pageviews),
+        "visitantes_unicos": len(ips_unicos),
+        "cliques_oferta": len(cliques),
+        "ctr": round(100 * len(cliques) / len(pageviews), 2) if pageviews else 0.0,
+        "checkouts": 0,  # evento de checkout ainda não instrumentado (webhooks: próxima parte)
+        "vendas": 0,     # vendas chegam via webhook (próxima parte)
+        "dias": days,
+    }
+
+    # --- Drenagem: IPs com cliques repetidos ---
+    cliques_por_ip = {}
+    for row in cliques:
+        if row["ip"]:
+            item = cliques_por_ip.setdefault(row["ip"], {"ip": row["ip"], "cliques": 0, "ultimo": row["created_at"], "user_agent": row["user_agent"], "eventos": 0})
+            item["cliques"] += 1
+            item["ultimo"] = max(item["ultimo"], row["created_at"])
+            item["user_agent"] = item["user_agent"] or row["user_agent"]
+    for row in pageviews:
+        if row["ip"] and row["ip"] in cliques_por_ip:
+            cliques_por_ip[row["ip"]]["eventos"] += 1
+    drenagem = sorted(
+        [v for v in cliques_por_ip.values() if v["cliques"] >= DRENAGEM_MIN_CLIQUE],
+        key=lambda v: v["cliques"],
+        reverse=True,
+    )[:50]
+
+    # --- Cards de visitantes (mais ativos) ---
+    visitantes = []
+    sample_por_ip = {}
+    for row in pageviews:
+        sample_por_ip.setdefault(row["ip"], row)
+    for ip, info in sorted(cliques_por_ip.items(), key=lambda kv: kv[1]["cliques"], reverse=True)[:12]:
+        sample = sample_por_ip.get(ip, {})
+        ua = parse_user_agent(info["user_agent"] or sample.get("user_agent"))
+        visitantes.append({
+            "ip": ip,
+            "visitor_id": visitor_id(ip),
+            "cliques": info["cliques"],
+            "ultimo": info["ultimo"],
+            "origem": (sample.get("utm_source") or _domain(sample.get("ref")) or "Acesso direto"),
+            "gclid": sample.get("gclid") or "",
+            **ua,
+        })
+    if not visitantes:
+        for ip, sample in list(sample_por_ip.items())[:6]:
+            ua = parse_user_agent(sample.get("user_agent"))
+            visitantes.append({
+                "ip": ip,
+                "visitor_id": visitor_id(ip),
+                "cliques": 0,
+                "ultimo": sample.get("created_at", ""),
+                "origem": (sample.get("utm_source") or _domain(sample.get("ref")) or "Acesso direto"),
+                "gclid": sample.get("gclid") or "",
+                **ua,
+            })
+
+    # --- Donuts ---
+    def aggregate(items, fallback="—"):
+        counts = {}
+        for item in items:
+            key = item or fallback
+            counts[key] = counts.get(key, 0) + 1
+        return sorted(counts.items(), key=lambda kv: kv[1], reverse=True)
+
+    origem = []
+    for row in pageviews:
+        origem.append(row["utm_source"] or _domain(row["ref"]) or "Acesso direto")
+    dispositivos = aggregate([parse_user_agent(r["user_agent"]).get("device", "—") for r in pageviews])
+    sistemas = aggregate([parse_user_agent(r["user_agent"]).get("os", "—") for r in pageviews])
+
+    # --- Funil ---
+    funil = {
+        "visitas": len(pageviews),
+        "cliques": len(cliques),
+        "checkouts": 0,
+        "vendas": 0,
+        "taxas": {
+            "cliques": round(100 * len(cliques) / len(pageviews), 2) if pageviews else 0,
+            "checkouts": 0.0,
+            "vendas": 0.0,
+        },
+    }
+
+    # --- Fluxo por hora (últimas 24 janelas com dados ou 24h) ---
+    por_hora = {}
+    for row in pageviews:
+        hora = (row["created_at"] or "")[:13]
+        if hora:
+            por_hora[hora] = por_hora.get(hora, 0) + 1
+    fluxo = sorted(por_hora.items())[-24:]
+    fluxo = [{"hora": h, "visitas": v} for h, v in fluxo]
+
+    return {
+        "resumo": resumo,
+        "drenagem": drenagem,
+        "visitantes": visitantes,
+        "origem": aggregate(origem)[:6],
+        "dispositivos": dispositivos,
+        "sistemas": sistemas,
+        "funil": funil,
+        "fluxo": fluxo,
+        "pixel_url": ((((get_settings().get("api_keys") or {}).get("tracking") or {}).get("pixel_url")) or "").strip(),
+    }
+
+
+def visitante(ip: str) -> dict:
+    with get_db() as conn:
+        rows = conn.execute(
+            "SELECT * FROM visitas WHERE ip = ? ORDER BY created_at DESC LIMIT 50",
+            (ip,),
+        ).fetchall()
+    rows = [dict(row) for row in rows]
+    if not rows:
+        return {"ip": ip, "visitor_id": visitor_id(ip), "eventos": [], "primeiro": "", "ultimo": "", "payload": {}}
+    first = rows[-1]
+    last = rows[0]
+    # Atribuição (gclid/utm/ref) vem do último PAGEVIEW; dispositivo do último evento
+    last_pageview = next((r for r in rows if r["event"] == "pageview"), last)
+    return {
+        "ip": ip,
+        "visitor_id": visitor_id(ip),
+        "primeiro": first["created_at"],
+        "ultimo": last["created_at"],
+        "eventos": [{"event": r["event"], "page": r["page"], "created_at": r["created_at"], "gclid": r["gclid"], "ref": r["ref"]} for r in rows],
+        "payload": {
+            "ipv4": ip,
+            "visitor_id": visitor_id(ip),
+            "is_ip_blocked": False,
+            "created_at": last["created_at"],
+            **parse_user_agent(last["user_agent"]),
+            "access_type": "humano (sem verificação de bot nesta versão)",
+            "gclid": last_pageview["gclid"] or "",
+            "utm_source": last_pageview["utm_source"] or "",
+            "utm_medium": last_pageview["utm_medium"] or "",
+            "utm_campaign": last_pageview["utm_campaign"] or "",
+            "ref": last_pageview["ref"] or "",
+        },
+    }