cdp-edge 2.3.8 → 2.5.1

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

@@ -9,6 +9,8 @@ import { sendCallMeBot } from './dispatch/whatsapp.js';
 import { autoDecideAbWinner } from './ml/ltv.js';
 import { analyzeMatchQuality, alertMatchQuality, purgeOldMatchQualityLogs } from './ml/matchquality.js';
 import { trainLogisticRegression, extractFeatures, saveWeights, LTV_WEIGHTS_KV_KEY } from './ml/logistic.js';
+import { computeRoasFeedback, sendRoasAlert } from './ml/roas.js';
+import { runNurtureQueue } from './nurture.js';
 import { Env } from '../types.js';
 
 // ── Tipos ───────────────────────────────────────────────────────────────────────
@@ -57,6 +59,22 @@ export interface IntelligenceAgentResult {
     skipped?: string;
     error?: string;
   };
+  roasResult?: {
+    campaigns: number;
+    total_revenue: number;
+    best_campaign: string | null;
+    skipped?: string;
+  };
+  nurtureResult?: {
+    processed: number;
+    sent: number;
+    failed: number;
+  };
+  lookalikeResult?: {
+    sent: number;
+    seed_type: string;
+    skipped?: string;
+  };
 }
 
 export interface CustomerMatchResult {
@@ -330,11 +348,50 @@ export async function runIntelligenceAgent(
     }
   }
 
-  // 8. Customer Match sync semanal
+  // 8. Customer Match sync semanal (high_intent → Meta Audience)
   const cmResult = await syncMetaCustomAudience(env);
   console.log(`[Intelligence Agent] Customer Match Meta: sent=${cmResult?.sent ?? 0}, received=${cmResult?.received ?? 0}`);
 
-  console.log(`[Intelligence Agent] ${runType} concluído — LTV model, A/B auto-decide, match quality, customer match`);
+  // 9. ROAS Feedback Loop — cruza leads com compras reais por campanha
+  let roasResult: IntelligenceAgentResult['roasResult'] = undefined;
+  try {
+    const report = await computeRoasFeedback(env, 30);
+    if (report) {
+      roasResult = {
+        campaigns:     report.campaigns.length,
+        total_revenue: report.total_revenue,
+        best_campaign: report.best_campaign,
+      };
+      await sendRoasAlert(env, report);
+      console.log(`[Intelligence Agent] ROAS: ${report.campaigns.length} campanhas, R$${report.total_revenue} receita`);
+    } else {
+      roasResult = { campaigns: 0, total_revenue: 0, best_campaign: null, skipped: 'sem dados suficientes' };
+    }
+  } catch (err: any) {
+    console.error('[Intelligence Agent] ROAS error:', err?.message || String(err));
+  }
+
+  // 10. Nurture Queue — processa mensagens agendadas (D+1, D+3, D+7)
+  let nurtureResult: IntelligenceAgentResult['nurtureResult'] = undefined;
+  try {
+    const nr = await runNurtureQueue(env);
+    nurtureResult = { processed: nr.processed, sent: nr.sent, failed: nr.failed };
+    console.log(`[Intelligence Agent] Nurture: ${nr.sent}/${nr.processed} mensagens enviadas`);
+  } catch (err: any) {
+    console.error('[Intelligence Agent] Nurture error:', err?.message || String(err));
+  }
+
+  // 11. Lookalike Dinâmico — compradores confirmados → Meta Audience seed
+  let lookalikeResult: IntelligenceAgentResult['lookalikeResult'] = undefined;
+  try {
+    const lr = await syncMetaLookalikeSeed(env);
+    lookalikeResult = lr;
+    console.log(`[Intelligence Agent] Lookalike seed: sent=${lr.sent}, type=${lr.seed_type}`);
+  } catch (err: any) {
+    console.error('[Intelligence Agent] Lookalike error:', err?.message || String(err));
+  }
+
+  console.log(`[Intelligence Agent] ${runType} concluído — LTV, A/B, match quality, customer match, ROAS, nurture, lookalike`);
 
   return {
     versionResults,
@@ -343,6 +400,9 @@ export async function runIntelligenceAgent(
     abResult,
     mqAnalysis,
     cmResult,
+    roasResult,
+    nurtureResult,
+    lookalikeResult,
   };
 }
 
@@ -400,6 +460,99 @@ export async function syncMetaCustomAudience(env: Env): Promise<CustomerMatchRes
   }
 }
 
+// ── syncMetaLookalikeSeed — compradores confirmados → Meta Audience (Fase 7) ──
+// Seed de Lookalike mais preciso: usa quem REALMENTE comprou (Purchase event)
+// em vez de quem só teve intenção (cohort_label = high_intent).
+// Separado do syncMetaCustomAudience para não misturar seeds de qualidade diferente.
+
+export async function syncMetaLookalikeSeed(env: Env): Promise<{
+  sent: number;
+  seed_type: string;
+  skipped?: string;
+}> {
+  if (!env.META_ACCESS_TOKEN || !env.META_AUDIENCE_ID) {
+    return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'META secrets não configurados' };
+  }
+  if (!env.DB) return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'DB não disponível' };
+
+  try {
+    // Busca perfis de compradores confirmados (Purchase event nos últimos 60 dias)
+    const confirmed = await env.DB.prepare(`
+      SELECT DISTINCT up.email, up.phone, up.first_name, up.last_name
+      FROM user_profiles up
+      JOIN leads l ON l.user_id = up.user_id
+      WHERE l.event_name IN ('Purchase','purchase')
+        AND l.created_at >= datetime('now', '-60 days')
+        AND up.email IS NOT NULL
+      UNION
+      SELECT DISTINCT up.email, up.phone, up.first_name, up.last_name
+      FROM user_profiles up
+      JOIN quiz_sessions qs ON qs.user_id = up.user_id
+      WHERE qs.qualification = 'comprador'
+        AND qs.created_at >= datetime('now', '-30 days')
+        AND up.email IS NOT NULL
+      LIMIT 10000
+    `).all();
+
+    if (!confirmed.results?.length) {
+      return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'nenhum comprador confirmado no período' };
+    }
+
+    const data = await Promise.all(
+      confirmed.results.map(async (p: any) => [
+        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() as any;
+
+    // Persiste histórico do seed
+    if (env.DB) {
+      await env.DB.prepare(`
+        INSERT INTO lookalike_seeds (audience_id, seed_type, profiles_sent, profiles_received, period_days)
+        VALUES (?, 'buyer_confirmed', ?, ?, 60)
+      `).bind(
+        env.META_AUDIENCE_ID,
+        confirmed.results.length,
+        result.num_received ?? null,
+      ).run().catch(() => {});
+    }
+
+    if (!res.ok) {
+      console.error('[Lookalike] Meta erro:', result.error?.message);
+      return { sent: 0, seed_type: 'buyer_confirmed', skipped: result.error?.message };
+    }
+
+    // Atualiza cohort_label dos compradores para buyer_confirmed
+    await env.DB.prepare(`
+      UPDATE user_profiles
+      SET cohort_label = 'buyer_confirmed', updated_at = datetime('now')
+      WHERE user_id IN (
+        SELECT DISTINCT user_id FROM leads
+        WHERE event_name IN ('Purchase','purchase')
+          AND created_at >= datetime('now', '-60 days')
+      )
+    `).run().catch(() => {});
+
+    console.log(`[Lookalike] ${confirmed.results.length} compradores confirmados enviados ao Meta`);
+    return { sent: confirmed.results.length, seed_type: 'buyer_confirmed' };
+
+  } catch (err: any) {
+    console.error('[Lookalike] syncMetaLookalikeSeed error:', err?.message || String(err));
+    return { sent: 0, seed_type: 'buyer_confirmed', skipped: err?.message };
+  }
+}
+
 // ── buildGoogleCustomerMatchExport — gera JSON para Google Ads Customer Match ─
 export async function buildGoogleCustomerMatchExport(env: Env): Promise<GoogleCustomerMatchExport[]> {
   if (!env.DB) return [];

package/server-edge-tracker/modules/ml/quiz.ts

@@ -0,0 +1,343 @@
+/**
+ * CDP Edge — Quiz Scoring Engine v2 (Fase 6)
+ *
+ * Análise Dimensional Automática via Workers AI (Granite 4.0 Micro):
+ *  1. Detecta o TIPO de cada pergunta (urgency, budget, timeline, fit, etc.)
+ *  2. Atribui peso automático por dimensão (budget/urgency > timeline > fit > awareness)
+ *  3. Pontua a resposta (0.0–1.0) dentro dessa dimensão
+ *  4. Calcula score ponderado final → qualification
+ *
+ * O front-end NÃO precisa declarar pesos — o engine infere tudo a partir
+ * do conteúdo da pergunta e da resposta.
+ */
+
+import { Env, TrackPayload } from '../../types.js';
+
+// ── Tipos públicos ─────────────────────────────────────────────────────────────
+
+export interface QuizAnswer {
+  question: string;
+  answer: string;
+  step?: number;
+}
+
+export type QuizQualification = 'comprador' | 'interessado' | 'curioso' | 'perdido';
+
+/** Dimensão detectada automaticamente pelo LLM para cada pergunta */
+export type QuizDimension =
+  | 'urgency'    // "preciso agora", "urgente" — peso 5
+  | 'budget'     // orçamento, financiamento, valor — peso 5
+  | 'timeline'   // prazo, quando, em quanto tempo — peso 3
+  | 'fit'        // perfil certo, problema real — peso 4
+  | 'engagement' // já pesquisou, visitou, comparou — peso 2
+  | 'awareness'  // conhece o produto/serviço — peso 1
+  | 'objection'  // dúvidas, barreiras, objeções — peso 3
+  | 'generic';   // pergunta sem dimensão clara — peso 1
+
+/** Análise por pergunta retornada pelo LLM */
+export interface QuizDimensionScore {
+  step: number;
+  dimension: QuizDimension;
+  score: number;      // 0.0–1.0 dentro da dimensão
+  weight: number;     // 1–5, inferido pelo LLM
+  signal: string;     // trecho ou palavra que motivou a nota
+}
+
+export interface QuizScoreResult {
+  qualification: QuizQualification;
+  intent_score: number;                     // 0.0–1.0 — compatível com resolveIntentScore()
+  weighted_score: number;                   // score ponderado bruto antes do mapeamento
+  confidence: number;                       // 0.0–1.0
+  reason: string;                           // frase curta em português para audit log
+  dominant_dimension: QuizDimension | null; // dimensão com maior impacto no score final
+  dimensions: QuizDimensionScore[];         // breakdown por pergunta (auditável)
+  source: 'ai' | 'heuristic';
+}
+
+// ── Prompt Granite — análise dimensional ──────────────────────────────────────
+// Instruções explícitas de formato para o modelo menor (Micro) respeitar o JSON.
+
+const QUIZ_DIMENSIONAL_PROMPT = `You are a lead qualification expert for the Brazilian digital marketing and sales funnel market.
+
+Your task: analyze each quiz question-answer pair and perform DIMENSIONAL SCORING.
+
+STEP 1 — For each Q&A pair, detect the DIMENSION:
+- "urgency":    question asks about timing urgency or immediate need ("agora", "urgente", "preciso já")
+- "budget":     question asks about money, price, investment, financing, credit approval
+- "timeline":   question asks about purchase timeframe (days/months/year)
+- "fit":        question checks if respondent matches the target profile or has the real problem
+- "engagement": question asks about prior research, visits, comparisons already done
+- "awareness":  question asks if they know the product/service/brand
+- "objection":  question surfaces doubts, barriers, or hesitations
+- "generic":    question has no clear commercial dimension
+
+STEP 2 — Score the ANSWER within that dimension (0.00 to 1.00):
+- 1.00 = strongest possible buying signal for this dimension
+- 0.50 = neutral or uncertain
+- 0.00 = negative signal (disqualifier)
+
+STEP 3 — Assign WEIGHT by dimension (do not change these mappings):
+- urgency: 5, budget: 5, fit: 4, timeline: 3, objection: 3, engagement: 2, awareness: 1, generic: 1
+
+STEP 4 — Compute weighted_score = SUM(score * weight) / SUM(weight) across all questions.
+
+STEP 5 — Map weighted_score to qualification:
+- 0.75–1.00 → "comprador"
+- 0.50–0.74 → "interessado"
+- 0.20–0.49 → "curioso"
+- 0.00–0.19 → "perdido"
+
+Reply ONLY with valid JSON. No markdown. No explanation outside the JSON:
+{
+  "dimensions": [
+    { "step": 1, "dimension": "<type>", "score": 0.00, "weight": 0, "signal": "<word or phrase>" }
+  ],
+  "weighted_score": 0.00,
+  "qualification": "<comprador|interessado|curioso|perdido>",
+  "confidence": 0.00,
+  "reason": "<one sentence in Portuguese>",
+  "dominant_dimension": "<dimension with highest score*weight product>"
+}`;
+
+// ── Pesos canônicos por dimensão (espelho do prompt — usado no fallback) ───────
+
+const DIMENSION_WEIGHTS: Record<QuizDimension, number> = {
+  urgency:    5,
+  budget:     5,
+  fit:        4,
+  timeline:   3,
+  objection:  3,
+  engagement: 2,
+  awareness:  1,
+  generic:    1,
+};
+
+// ── Mapeamento de score ponderado → intent_score suavizado ────────────────────
+// O weighted_score é uma média ponderada de scores por dimensão (0-1).
+// O intent_score preserva a mesma escala mas com limites por faixa.
+
+function _weightedToIntentScore(ws: number, qual: QuizQualification): number {
+  // Mantém o score contínuo dentro da faixa da qualificação para não perder granularidade
+  const ranges: Record<QuizQualification, [number, number]> = {
+    comprador:   [0.80, 1.00],
+    interessado: [0.50, 0.79],
+    curioso:     [0.20, 0.49],
+    perdido:     [0.00, 0.19],
+  };
+  const [lo, hi] = ranges[qual];
+  return _clamp(lo + (ws - lo) * ((hi - lo) / Math.max(hi - lo, 0.01)));
+}
+
+// ── scoreQuizAnswers — função principal ───────────────────────────────────────
+
+export async function scoreQuizAnswers(
+  env: Env,
+  answers: QuizAnswer[],
+  quizName?: string | null,
+): Promise<QuizScoreResult> {
+  if (!answers || answers.length === 0) {
+    return _fallback([], 'Nenhuma resposta recebida');
+  }
+
+  // Tenta via Workers AI
+  if (env.AI) {
+    try {
+      const answersText = answers
+        .map((a, i) => `P${a.step ?? i + 1}: "${a.question}" → "${a.answer}"`)
+        .join('\n');
+
+      const contextMsg = quizName
+        ? `Quiz: "${quizName}"\n\n${answersText}`
+        : answersText;
+
+      // max_tokens: ~80 por dimensão × N perguntas + ~120 para o envelope final
+      const maxTokens = Math.min(512, 120 + answers.length * 80);
+
+      const aiRes = await env.AI.run('@cf/ibm-granite/granite-4.0-h-micro', {
+        messages: [
+          { role: 'system', content: QUIZ_DIMENSIONAL_PROMPT },
+          { role: 'user',   content: contextMsg },
+        ],
+        max_tokens: maxTokens,
+      });
+
+      const raw = (aiRes as any)?.response?.trim() ?? '';
+      const jsonMatch = raw.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) throw new Error('AI response has no JSON block');
+
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      // Valida e normaliza dimensions[]
+      const dimensions: QuizDimensionScore[] = Array.isArray(parsed.dimensions)
+        ? (parsed.dimensions as any[]).map((d, i) => ({
+            step:      typeof d.step === 'number' ? d.step : i + 1,
+            dimension: _validateDimension(d.dimension),
+            score:     _clamp(parseFloat(String(d.score ?? 0.5))),
+            weight:    typeof d.weight === 'number' ? Math.min(5, Math.max(1, d.weight)) : 1,
+            signal:    String(d.signal || '').slice(0, 100),
+          }))
+        : [];
+
+      // Recalcula weighted_score no servidor (não confia cegamente no modelo)
+      const weighted_score = _computeWeightedScore(dimensions);
+
+      const qualification     = _validateQualification(parsed.qualification);
+      const intent_score      = _weightedToIntentScore(weighted_score, qualification);
+      const confidence        = _clamp(parseFloat(String(parsed.confidence ?? 0.7)));
+      const reason            = String(parsed.reason || '').slice(0, 200);
+      const dominant_dimension = _validateDimension(parsed.dominant_dimension) as QuizDimension | null;
+
+      return {
+        qualification,
+        intent_score,
+        weighted_score,
+        confidence,
+        reason,
+        dominant_dimension,
+        dimensions,
+        source: 'ai',
+      };
+
+    } catch (err: any) {
+      console.warn('[QuizScoring] AI falhou, usando heurística:', err?.message || String(err));
+    }
+  }
+
+  return _fallback(answers, 'Workers AI indisponível');
+}
+
+// ── saveQuizSession — persiste no D1 em background ───────────────────────────
+
+export async function saveQuizSession(
+  env: Env,
+  userId: string | null | undefined,
+  payload: TrackPayload,
+  result: QuizScoreResult,
+): Promise<void> {
+  if (!env.DB) return;
+  try {
+    await env.DB.prepare(`
+      INSERT INTO quiz_sessions (
+        user_id, quiz_name, answers_json,
+        qualification, intent_score, weighted_score, confidence,
+        reason, dominant_dimension, dimensions_json, source, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    `).bind(
+      userId                               || null,
+      String(payload.quiz_name || ''),
+      JSON.stringify(payload.quiz_answers  || []),
+      result.qualification,
+      result.intent_score,
+      result.weighted_score,
+      result.confidence,
+      result.reason,
+      result.dominant_dimension            || null,
+      JSON.stringify(result.dimensions),
+      result.source,
+    ).run();
+  } catch (err: any) {
+    console.error('[QuizScoring] saveQuizSession error:', err?.message || String(err));
+  }
+}
+
+// ── Helpers internos ──────────────────────────────────────────────────────────
+
+function _clamp(n: number): number {
+  if (isNaN(n)) return 0;
+  return Math.min(1, Math.max(0, Math.round(n * 100) / 100));
+}
+
+function _validateQualification(val: unknown): QuizQualification {
+  const valid: QuizQualification[] = ['comprador', 'interessado', 'curioso', 'perdido'];
+  return valid.includes(val as QuizQualification) ? (val as QuizQualification) : 'curioso';
+}
+
+function _validateDimension(val: unknown): QuizDimension {
+  const valid: QuizDimension[] = ['urgency','budget','timeline','fit','engagement','awareness','objection','generic'];
+  return valid.includes(val as QuizDimension) ? (val as QuizDimension) : 'generic';
+}
+
+function _computeWeightedScore(dims: QuizDimensionScore[]): number {
+  if (!dims.length) return 0;
+  const sumWS  = dims.reduce((acc, d) => acc + d.score * d.weight, 0);
+  const sumW   = dims.reduce((acc, d) => acc + d.weight, 0);
+  return _clamp(sumW > 0 ? sumWS / sumW : 0);
+}
+
+// ── Fallback heurístico dimensional ──────────────────────────────────────────
+// Quando Workers AI está indisponível, classifica por padrões de texto
+// e gera um breakdown dimensional sintético para manter consistência de contrato.
+
+const HEURISTIC_DIMENSION_PATTERNS: Array<{
+  dimension: QuizDimension;
+  patterns: string[];
+}> = [
+  { dimension: 'urgency',    patterns: ['agora','hoje','urgente','imediato','já','preciso logo','não posso esperar'] },
+  { dimension: 'budget',     patterns: ['orçamento','budget','financiamento','aprovado','crédito','dinheiro','quanto custa','valor','posso pagar','tenho recurso'] },
+  { dimension: 'timeline',   patterns: ['mês','meses','semana','semanas','ano','prazo','quando','breve','futuramente','em quanto tempo'] },
+  { dimension: 'fit',        patterns: ['sim','é para mim','tenho esse problema','preciso disso','faz sentido','encaixa','me identifico'] },
+  { dimension: 'engagement', patterns: ['já pesquisei','comparei','visitei','já vi','pesquisando','avaliando','testei'] },
+  { dimension: 'awareness',  patterns: ['conheço','já ouvi','sabia','já usei','familiar'] },
+  { dimension: 'objection',  patterns: ['mas','porém','dúvida','não tenho certeza','talvez','depende','preciso pensar','não sei'] },
+];
+
+const HEURISTIC_QUAL_SCORE: Record<QuizQualification, number> = {
+  comprador: 0.87, interessado: 0.62, curioso: 0.30, perdido: 0.10,
+};
+
+function _fallback(answers: QuizAnswer[], note: string): QuizScoreResult {
+  // Gera breakdown dimensional sintético por pergunta
+  const dimensions: QuizDimensionScore[] = answers.map((a, i) => {
+    const text = `${a.question} ${a.answer}`.toLowerCase();
+
+    let bestDim: QuizDimension = 'generic';
+    let bestScore = 0.4; // neutro
+    let bestSignal = '';
+
+    for (const { dimension, patterns } of HEURISTIC_DIMENSION_PATTERNS) {
+      const matched = patterns.filter(p => text.includes(p));
+      if (matched.length > 0) {
+        // Score positivo se resposta tem sinal de compra, negativo se objeção
+        const baseScore = dimension === 'objection' ? 0.3 : 0.75;
+        if (baseScore > bestScore || (bestDim === 'generic' && matched.length > 0)) {
+          bestDim    = dimension;
+          bestScore  = baseScore;
+          bestSignal = matched[0];
+        }
+      }
+    }
+
+    return {
+      step:      a.step ?? i + 1,
+      dimension: bestDim,
+      score:     bestScore,
+      weight:    DIMENSION_WEIGHTS[bestDim],
+      signal:    bestSignal || a.answer.slice(0, 60),
+    };
+  });
+
+  const weighted_score = _computeWeightedScore(dimensions.length ? dimensions : [{ step:1, dimension:'generic', score:0.3, weight:1, signal:'' }]);
+
+  const qualification: QuizQualification =
+    weighted_score >= 0.75 ? 'comprador'   :
+    weighted_score >= 0.50 ? 'interessado' :
+    weighted_score >= 0.20 ? 'curioso'     : 'perdido';
+
+  // Dimensão dominante = maior produto score × weight
+  const dominant = dimensions.length
+    ? dimensions.reduce((best, d) =>
+        (d.score * d.weight > best.score * best.weight ? d : best)
+      ).dimension
+    : null;
+
+  return {
+    qualification,
+    intent_score:        _clamp(HEURISTIC_QUAL_SCORE[qualification]),
+    weighted_score,
+    confidence:          Math.min(0.6, 0.25 + dimensions.filter(d => d.signal).length * 0.07),
+    reason:              `${note}. Score ponderado heurístico: ${(weighted_score * 100).toFixed(0)}/100.`,
+    dominant_dimension:  dominant as QuizDimension | null,
+    dimensions,
+    source:              'heuristic',
+  };
+}