cdp-edge 2.0.2 → 2.0.4

package/server-edge-tracker/modules/intelligence.js

@@ -0,0 +1,204 @@
+/**
+ * CDP Edge — Intelligence Agent + Customer Match
+ * runIntelligenceAgent, customer match Meta/Google, health checks
+ */
+
+import { sha256 } from './utils.js';
+import { getHealthMetrics, generateDailyReport, logIntelligence } from './db.js';
+import { sendCallMeBot } from './dispatch/whatsapp.js';
+
+// ── Versões esperadas das APIs ────────────────────────────────────────────────
+const EXPECTED_API_VERSIONS = {
+  meta:      'v22.0',
+  ga4:       'latest',
+  tiktok:    'v1.3',
+  pinterest: 'v5',
+  reddit:    'v2.0',
+};
+
+const ALERT_THRESHOLDS = {
+  errorRateCritical: 0.20,
+  errorRateWarning:  0.10,
+};
+
+// ── Alerta via CallMeBot ──────────────────────────────────────────────────────
+export async function sendIntelligenceAlert(env, severity, title, details) {
+  const icon  = severity === 'critical' ? '🚨' : '⚠️';
+  const texto = `${icon} CDP Edge — ${title}\n\n${details}\n\n${new Date().toLocaleString('pt-BR', { timeZone: 'America/Sao_Paulo' })}`;
+  return sendCallMeBot(env, texto);
+}
+
+// ── Check de versões de API ───────────────────────────────────────────────────
+export async function checkApiVersionsIntelligence(env, runType) {
+  const results = [];
+
+  for (const [platform, expected] of Object.entries(EXPECTED_API_VERSIONS)) {
+    const currentMap = { meta: 'v22.0', tiktok: 'v1.3', ga4: 'latest', pinterest: 'v5', reddit: 'v2.0' };
+    const current    = currentMap[platform] || 'unknown';
+    const isOk       = current === expected || expected === 'latest';
+    const status     = isOk ? 'ok' : 'warning';
+
+    await logIntelligence(env.DB, runType, platform, 'api_version', status, current, expected,
+      isOk ? `${platform} ${current} — versão correta` : `${platform} ${current} desatualizado, esperado ${expected}`
+    );
+
+    results.push({ platform, current, expected, status });
+  }
+
+  return results;
+}
+
+// ── Auditoria de taxa de erro ─────────────────────────────────────────────────
+export async function auditErrorRates(env, runType) {
+  if (!env.DB) return [];
+  const alerts = [];
+
+  for (const platform of ['meta', 'ga4', 'tiktok']) {
+    const metrics   = await getHealthMetrics(env.DB, platform, 24);
+    const errorRate = metrics.events_sent > 0 ? metrics.events_failed / metrics.events_sent : 0;
+
+    let status = 'ok';
+    if (errorRate >= ALERT_THRESHOLDS.errorRateCritical) status = 'critical';
+    else if (errorRate >= ALERT_THRESHOLDS.errorRateWarning) status = 'warning';
+
+    const message   = `${platform}: ${metrics.events_sent} eventos, ${metrics.events_failed} falhas (${(errorRate * 100).toFixed(1)}%)`;
+    const alertSent = status !== 'ok'
+      ? await sendIntelligenceAlert(env, status, `Taxa de Erro Alta — ${platform.toUpperCase()}`,
+          `📊 ${message}\n🎯 Taxa: ${(errorRate * 100).toFixed(1)}% (limite: ${ALERT_THRESHOLDS.errorRateWarning * 100}%)`)
+      : false;
+
+    await logIntelligence(env.DB, runType, platform, 'error_rate', status,
+      `${(errorRate * 100).toFixed(1)}%`, `${ALERT_THRESHOLDS.errorRateWarning * 100}%`, message, alertSent
+    );
+
+    if (status !== 'ok') alerts.push({ platform, errorRate, status });
+  }
+
+  return alerts;
+}
+
+// ── Runner principal do Intelligence Agent ────────────────────────────────────
+export async function runIntelligenceAgent(env, runType) {
+  console.log(`[Intelligence Agent] Iniciando ${runType}`);
+
+  // 1. Check de versões
+  const versionResults = await checkApiVersionsIntelligence(env, runType);
+  console.log(`[Intelligence Agent] Versões verificadas: ${versionResults.length} plataformas`);
+
+  // 2. Relatório diário
+  if (env.DB) {
+    const reports = await generateDailyReport(env.DB);
+    console.log(`[Intelligence Agent] Relatórios gerados: ${reports.length}`);
+  }
+
+  // 3. Auditoria de taxas de erro
+  const errorAlerts = await auditErrorRates(env, runType);
+  if (errorAlerts.length > 0) {
+    console.warn(`[Intelligence Agent] ${errorAlerts.length} alertas de taxa de erro enviados`);
+  }
+
+  // 4. Auditoria mensal adicional
+  if (runType === 'monthly_audit') {
+    if (env.DB) {
+      try {
+        const ltvStats = await env.DB.prepare(`
+          SELECT predicted_ltv_class, COUNT(*) as count
+          FROM user_profiles
+          WHERE predicted_ltv_class IS NOT NULL AND updated_at > datetime('now', '-30 days')
+          GROUP BY predicted_ltv_class
+        `).all();
+
+        const summary = ltvStats.results?.map(r => `${r.predicted_ltv_class}: ${r.count}`).join(', ') || 'sem dados';
+        await logIntelligence(env.DB, runType, 'all', 'ltv_distribution', 'ok', summary, null,
+          `Distribuição LTV últimos 30 dias: ${summary}`);
+        console.log(`[Intelligence Agent] LTV distribution: ${summary}`);
+      } catch (err) {
+        console.error('LTV audit error:', err.message);
+      }
+    }
+  }
+
+  // 5. Customer Match sync semanal
+  const cmResult = await syncMetaCustomAudience(env);
+  console.log(`[Intelligence Agent] Customer Match Meta: sent=${cmResult?.sent ?? 0}, received=${cmResult?.num_received ?? 0}`);
+
+  console.log(`[Intelligence Agent] ${runType} concluído`);
+}
+
+// ── syncMetaCustomAudience — D1 → Meta Custom Audiences ─────────────────────
+export async function syncMetaCustomAudience(env) {
+  if (!env.META_ACCESS_TOKEN || !env.META_AD_ACCOUNT_ID || !env.META_AUDIENCE_ID) {
+    console.log('[CustomerMatch] Meta: secrets não configurados — pulando sync');
+    return { skipped: 'META_AD_ACCOUNT_ID ou META_AUDIENCE_ID não configurados' };
+  }
+  if (!env.DB) return { skipped: 'DB não disponível' };
+
+  try {
+    const profiles = await env.DB.prepare(`
+      SELECT email, phone FROM user_profiles
+      WHERE cohort_label IN ('high_intent', 'buyer_lookalike')
+        AND updated_at > datetime('now', '-30 days')
+        AND email IS NOT NULL
+      LIMIT 10000
+    `).all();
+
+    if (!profiles.results || profiles.results.length === 0) {
+      console.log('[CustomerMatch] Meta: nenhum perfil elegível');
+      return { sent: 0 };
+    }
+
+    const data = await Promise.all(
+      profiles.results.map(async (p) => [
+        p.email ? await sha256(p.email) : '',
+        p.phone ? await sha256(p.phone) : '',
+      ])
+    );
+
+    const body = { payload: { schema: ['EMAIL_SHA256', 'PHONE_SHA256'], data } };
+    const endpoint = `https://graph.facebook.com/v22.0/${env.META_AUDIENCE_ID}/users`;
+
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ ...body, access_token: env.META_ACCESS_TOKEN }),
+    });
+
+    const result = await res.json();
+
+    if (!res.ok) {
+      console.error('[CustomerMatch] Meta erro:', res.status, result.error?.message || 'unknown');
+      return { error: result.error?.message, sent: 0 };
+    }
+
+    console.log(`[CustomerMatch] Meta: ${profiles.results.length} perfis sincronizados`);
+    return { sent: profiles.results.length, num_received: result.num_received };
+
+  } catch (err) {
+    console.error('[CustomerMatch] Meta fetch error:', err.message);
+    return { error: err.message, sent: 0 };
+  }
+}
+
+// ── buildGoogleCustomerMatchExport — gera JSON para Google Ads Customer Match ─
+export async function buildGoogleCustomerMatchExport(env) {
+  if (!env.DB) return [];
+
+  const profiles = await env.DB.prepare(`
+    SELECT email, phone, first_name, last_name FROM user_profiles
+    WHERE cohort_label IN ('high_intent', 'buyer_lookalike')
+      AND updated_at > datetime('now', '-30 days')
+      AND email IS NOT NULL
+    LIMIT 10000
+  `).all();
+
+  if (!profiles.results?.length) return [];
+
+  return Promise.all(
+    profiles.results.map(async (p) => ({
+      hashed_email: p.email ? await sha256(p.email) : '',
+      hashed_phone: p.phone ? await sha256(p.phone) : '',
+      first_name:   p.first_name || '',
+      last_name:    p.last_name  || '',
+    }))
+  );
+}

package/server-edge-tracker/modules/ml/bidding.js

@@ -0,0 +1,245 @@
+/**
+ * CDP Edge — Bidding Recommendations ML (Fase 2)
+ * Handlers das rotas /api/bidding/*
+ */
+
+import { tryParseJson } from '../utils.js';
+
+// ── Constantes de calibração ──────────────────────────────────────────────────
+const PLATFORM_FACTORS = { meta: 0.85, google: 0.90, tiktok: 0.75 };
+
+function getSegmentMultiplier(avgLtvClass, avgBehaviorScore) {
+  const ltv = parseFloat(avgLtvClass    || 0);
+  const eng = parseFloat(avgBehaviorScore || 0);
+  if (ltv >= 0.7 && eng >= 0.7)  return 1.4;
+  if (ltv >= 0.7 && eng >= 0.4)  return 1.2;
+  if (ltv >= 0.4 && eng >= 0.7)  return 1.0;
+  if (ltv >= 0.4 && eng >= 0.4)  return 0.8;
+  return 0.6;
+}
+
+function getConfidenceAdjustment(confidence) {
+  if (confidence >= 0.7) return 1.00;
+  if (confidence >= 0.4) return 0.85;
+  return 0.70;
+}
+
+// ── POST /api/bidding/recommend ───────────────────────────────────────────────
+export async function handleBiddingRecommend(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  let body;
+  try { body = await request.json(); }
+  catch { return new Response(JSON.stringify({ error: 'JSON inválido no body' }), { status: 400, headers }); }
+
+  const {
+    vertical    = 'geral', platform    = 'meta',
+    target_roi  = 3.5,    period_days = 30,
+    campaign_id = null,   budget      = null,
+  } = body;
+
+  const platforms = platform === 'all'
+    ? Object.keys(PLATFORM_FACTORS)
+    : [platform].filter(p => PLATFORM_FACTORS[p]);
+
+  if (platforms.length === 0) {
+    return new Response(JSON.stringify({ error: 'platform deve ser: meta, google, tiktok ou all' }), { status: 400, headers });
+  }
+  if (target_roi < 1 || target_roi > 20) {
+    return new Response(JSON.stringify({ error: 'target_roi deve estar entre 1 e 20' }), { status: 400, headers });
+  }
+
+  try {
+    const segmentsRes = await env.DB.prepare(`
+      SELECT ms.id AS segment_id, ms.cluster_name, ms.avg_ltv_class, ms.avg_behavior_score,
+             ms.avg_engagement_score, ms.silhouette_score,
+             COUNT(msm.id) AS member_count,
+             AVG(l.predicted_ltv) AS real_avg_ltv,
+             SUM(CASE WHEN l.event_name IN ('Purchase','CompletePayment') THEN 1 ELSE 0 END) AS conversions
+      FROM ml_segments ms
+      LEFT JOIN ml_segment_members msm ON msm.cluster_id = ms.id
+      LEFT JOIN leads l ON CAST(msm.lead_id AS INTEGER) = l.id
+        AND l.created_at >= datetime('now', '-' || ? || ' days')
+      WHERE ms.is_active = 1 AND ms.client_vertical IN (?, 'general')
+      GROUP BY ms.id
+      HAVING member_count > 0
+      ORDER BY real_avg_ltv DESC
+      LIMIT 10
+    `).bind(period_days, vertical).all();
+
+    const segments = segmentsRes.results || [];
+
+    let globalLtv = 0, globalLeads = 0, globalConversions = 0;
+    if (segments.length === 0) {
+      const globalRes = await env.DB.prepare(`
+        SELECT COUNT(*) AS total_leads, AVG(predicted_ltv) AS avg_ltv,
+               SUM(CASE WHEN event_name IN ('Purchase','CompletePayment') THEN 1 ELSE 0 END) AS conversions
+        FROM leads
+        WHERE created_at >= datetime('now', '-' || ? || ' days')
+          AND (bot_score IS NULL OR bot_score < 2)
+      `).bind(period_days).first();
+
+      globalLeads       = globalRes?.total_leads  || 0;
+      globalLtv         = globalRes?.avg_ltv       || 0;
+      globalConversions = globalRes?.conversions    || 0;
+
+      if (globalLeads < 10) {
+        return new Response(JSON.stringify({
+          error: `Dados insuficientes. Apenas ${globalLeads} leads no período de ${period_days} dias. Mínimo: 10.`,
+          leads_found: globalLeads, required: 10,
+        }), { status: 400, headers });
+      }
+    }
+
+    const now = new Date().toISOString();
+    const recommendations = [];
+
+    const targetSegments = segments.length > 0
+      ? segments
+      : [{ segment_id: null, cluster_name: 'Global (sem segmentação)', avg_ltv_class: 0.5, avg_behavior_score: 0.5, avg_engagement_score: 0.5, member_count: globalLeads, real_avg_ltv: globalLtv, conversions: globalConversions }];
+
+    for (const seg of targetSegments) {
+      const avgLtv     = parseFloat(seg.real_avg_ltv || 0);
+      const convs      = parseInt(seg.conversions || 0);
+      const confidence = Math.min(1, convs / 100);
+
+      const estimatedLtv = avgLtv > 0 ? avgLtv :
+        seg.avg_ltv_class >= 0.7 ? 497 : seg.avg_ltv_class >= 0.4 ? 297 : 97;
+
+      const cpaTarget    = estimatedLtv / target_roi;
+      const segMult      = getSegmentMultiplier(seg.avg_ltv_class, seg.avg_behavior_score);
+      const confAdj      = getConfidenceAdjustment(confidence);
+      const alertMsg     = convs < 30 ? `Atenção: apenas ${convs} conversões no período. Bid baseado em estimativa de LTV — aplique com cautela.` : null;
+
+      for (const plat of platforms) {
+        const platFactor     = PLATFORM_FACTORS[plat];
+        const recommendedBid = Math.max(5, cpaTarget * platFactor * segMult * confAdj);
+        const expectedRoi    = estimatedLtv / (recommendedBid / platFactor);
+
+        const reasoning = `Segmento "${seg.cluster_name}": LTV=${estimatedLtv.toFixed(0)} BRL, ` +
+          `CPA_alvo=${cpaTarget.toFixed(0)} BRL, fator_plataforma=${platFactor}, ` +
+          `mult_segmento=${segMult}, ajuste_confiança=${confAdj}, ` +
+          `base: ${convs} conversões em ${period_days} dias.`;
+
+        try {
+          await env.DB.prepare(`
+            INSERT INTO bid_recommendations (
+              generated_at, vertical, platform, period_days, target_roi,
+              segment_id, segment_name, leads_analyzed, conversions_found,
+              avg_ltv, cpa_target, recommended_bid, bid_currency,
+              confidence, expected_roi, reasoning, ai_used, alert_message,
+              platform_factor, confidence_adjustment, segment_multiplier, is_active
+            ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,0,?,?,?,?,1)
+          `).bind(
+            now, vertical, plat, period_days, target_roi,
+            seg.segment_id || null, seg.cluster_name,
+            seg.member_count || globalLeads, convs,
+            estimatedLtv, cpaTarget, recommendedBid, 'BRL',
+            confidence, expectedRoi, reasoning, alertMsg || null,
+            platFactor, confAdj, segMult,
+          ).run();
+        } catch (e) { console.error('[Bidding] D1 insert error:', e.message); }
+
+        recommendations.push({
+          platform: plat, segment: seg.cluster_name, segment_id: seg.segment_id || null,
+          avg_ltv: Math.round(estimatedLtv * 100) / 100,
+          avg_ltv_class: seg.avg_ltv_class >= 0.7 ? 'High' : seg.avg_ltv_class >= 0.4 ? 'Medium' : 'Low',
+          cpa_target: Math.round(cpaTarget * 100) / 100,
+          recommended_bid: Math.round(recommendedBid * 100) / 100,
+          bid_currency: 'BRL', confidence: Math.round(confidence * 100) / 100,
+          expected_roi: Math.round(expectedRoi * 100) / 100, reasoning, alert: alertMsg,
+        });
+      }
+    }
+
+    await env.DB.prepare(`UPDATE bid_recommendations SET is_active = 0 WHERE vertical = ? AND generated_at < ? AND is_active = 1`).bind(vertical, now).run().catch(() => {});
+
+    const avgConfidence = recommendations.length > 0
+      ? recommendations.reduce((s, r) => s + r.confidence, 0) / recommendations.length
+      : 0;
+
+    return new Response(JSON.stringify({
+      success: true, generated_at: now, vertical, period_days, target_roi,
+      data_quality: {
+        leads_analyzed: targetSegments.reduce((s, sg) => s + (sg.member_count || 0), 0),
+        conversions_found: targetSegments.reduce((s, sg) => s + (sg.conversions || 0), 0),
+        segments_active: segments.length, confidence: Math.round(avgConfidence * 100) / 100,
+      },
+      recommendations,
+      global_summary: {
+        total_recommendations: recommendations.length,
+        avg_confidence: Math.round(avgConfidence * 100) / 100,
+        expected_cost_reduction: avgConfidence >= 0.7 ? '-20%' : avgConfidence >= 0.4 ? '-10%' : 'indefinido (dados insuficientes)',
+        segments_analyzed: segments.length,
+      },
+    }), { status: 200, headers });
+
+  } catch (err) {
+    console.error('[Bidding] recommend error:', err.message);
+    return new Response(JSON.stringify({ error: 'Erro ao gerar recomendações', message: err.message }), { status: 500, headers });
+  }
+}
+
+// ── GET /api/bidding/history ──────────────────────────────────────────────────
+export async function handleBiddingHistory(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  const url      = new URL(request.url);
+  const vertical = url.searchParams.get('vertical') || null;
+  const platform = url.searchParams.get('platform') || null;
+  const limit    = Math.min(parseInt(url.searchParams.get('limit') || '20'), 100);
+
+  try {
+    const conditions = [];
+    const bindings   = [];
+    if (vertical) { conditions.push('vertical = ?');  bindings.push(vertical); }
+    if (platform) { conditions.push('platform = ?');  bindings.push(platform); }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+    const result = await env.DB.prepare(`
+      SELECT id, generated_at, vertical, platform, period_days, target_roi,
+             segment_name, leads_analyzed, conversions_found, avg_ltv, cpa_target,
+             recommended_bid, bid_currency, confidence, expected_roi,
+             reasoning, alert_message, ai_used, is_active,
+             applied_at, applied_campaign, applied_result
+      FROM bid_recommendations
+      ${where}
+      ORDER BY generated_at DESC
+      LIMIT ?
+    `).bind(...bindings, limit).all();
+
+    const items = (result.results || []).map(r => ({ ...r, applied_result: tryParseJson(r.applied_result, null) }));
+    return new Response(JSON.stringify({ success: true, total: items.length, history: items }), { status: 200, headers });
+  } catch (err) {
+    console.error('[Bidding] history error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}
+
+// ── GET /api/bidding/status ───────────────────────────────────────────────────
+export async function handleBiddingStatus(env, request, headers) {
+  if (!env.DB) return new Response(JSON.stringify({ error: 'DB não configurado' }), { status: 503, headers });
+
+  const url      = new URL(request.url);
+  const vertical = url.searchParams.get('vertical') || null;
+
+  try {
+    let query = `
+      SELECT platform, vertical, MAX(generated_at) as last_generated,
+             AVG(confidence) as avg_confidence, AVG(recommended_bid) as avg_bid,
+             COUNT(*) as recommendations_count,
+             SUM(CASE WHEN alert_message IS NOT NULL THEN 1 ELSE 0 END) as alerts_count
+      FROM bid_recommendations
+      WHERE is_active = 1
+    `;
+    const bindings = [];
+    if (vertical) { query += ' AND vertical = ?'; bindings.push(vertical); }
+    query += ' GROUP BY platform, vertical ORDER BY last_generated DESC';
+
+    const result = await env.DB.prepare(query).bind(...bindings).all();
+    return new Response(JSON.stringify({ success: true, status: result.results || [] }), { status: 200, headers });
+  } catch (err) {
+    console.error('[Bidding] status error:', err.message);
+    return new Response(JSON.stringify({ error: err.message }), { status: 500, headers });
+  }
+}