Ad Creative Audit

import os, time, json, glob, requests

API_KEY = os.environ["MAVERA_API_KEY"]
WORKSPACE_ID = os.environ["MAVERA_WORKSPACE_ID"]
BASE = "https://app.mavera.io/api/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}


def upload_video(path: str) -> dict:
    with open(path, "rb") as f:
        content = f.read()
    name = os.path.basename(path)
    mime = "video/mp4" if path.lower().endswith(".mp4") else "video/quicktime"

    url_resp = requests.post(f"{BASE}/files/upload-url", headers=HEADERS, json={
        "file_name": name, "file_type": mime,
        "file_size": len(content), "workspace_id": WORKSPACE_ID,
    }).json()
    if "error" in url_resp:
        raise Exception(url_resp["error"]["message"])

    requests.put(url_resp["upload_url"], data=content,
                 headers={"Content-Type": mime}).raise_for_status()

    file_rec = requests.post(f"{BASE}/files", headers=HEADERS, json={
        "name": name, "type": mime, "url": url_resp["public_url"],
        "workspace_id": WORKSPACE_ID, "file_size": len(content),
    }).json()
    if "error" in file_rec:
        raise Exception(file_rec["error"]["message"])
    return {"id": file_rec["id"], "name": name}


def upload_all(directory: str) -> list[dict]:
    paths = sorted(glob.glob(os.path.join(directory, "*.mp4"))
                   + glob.glob(os.path.join(directory, "*.mov")))
    if not paths:
        raise FileNotFoundError(f"No video files in {directory}")
    assets = []
    for p in paths:
        asset = upload_video(p)
        print(f"  Uploaded {asset['name']} → {asset['id']}")
        assets.append(asset)
    return assets

const fs = require("fs");
const path = require("path");

const API_KEY = process.env.MAVERA_API_KEY;
const WORKSPACE_ID = process.env.MAVERA_WORKSPACE_ID;
const BASE = "https://app.mavera.io/api/v1";
const HEADERS = { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" };

async function uploadVideo(videoPath) {
  const content = fs.readFileSync(videoPath);
  const name = path.basename(videoPath);
  const mime = videoPath.toLowerCase().endsWith(".mp4") ? "video/mp4" : "video/quicktime";

  const urlResp = await fetch(`${BASE}/files/upload-url`, {
    method: "POST", headers: HEADERS,
    body: JSON.stringify({ file_name: name, file_type: mime, file_size: content.length, workspace_id: WORKSPACE_ID }),
  }).then((r) => r.json());
  if (urlResp.error) throw new Error(urlResp.error.message);

  await fetch(urlResp.upload_url, { method: "PUT", body: content, headers: { "Content-Type": mime } });

  const fileRec = await fetch(`${BASE}/files`, {
    method: "POST", headers: HEADERS,
    body: JSON.stringify({ name, type: mime, url: urlResp.public_url, workspace_id: WORKSPACE_ID, file_size: content.length }),
  }).then((r) => r.json());
  if (fileRec.error) throw new Error(fileRec.error.message);
  return { id: fileRec.id, name };
}

async function uploadAll(directory) {
  const files = fs.readdirSync(directory).filter((f) => /\.(mp4|mov)$/i.test(f)).sort().map((f) => path.join(directory, f));
  if (!files.length) throw new Error(`No video files in ${directory}`);
  const assets = [];
  for (const fp of files) { const a = await uploadVideo(fp); console.log(`  Uploaded ${a.name} → ${a.id}`); assets.push(a); }
  return assets;
}

def create_analysis(asset_id: str, label: str) -> dict:
    resp = requests.post(f"{BASE}/video-analyses", headers=HEADERS, json={
        "title": f"Q4 Audit: {label}", "asset_id": asset_id,
        "goal": "Score ad effectiveness: engagement, emotion, attention, brand recall, CTA",
        "brand": "Brand", "product": "Product",
        "primary_intent": "Drive purchase consideration",
        "chunk_duration": 5, "frames_per_chunk": 3, "workspace_id": WORKSPACE_ID,
    }).json()
    if "error" in resp:
        raise Exception(resp["error"]["message"])
    return resp


def poll_analysis(analysis_id: str, timeout_min: int = 20) -> dict:
    for _ in range(timeout_min * 4):
        resp = requests.get(f"{BASE}/video-analyses/{analysis_id}", headers=HEADERS).json()
        if "error" in resp:
            raise Exception(resp["error"]["message"])
        if resp["status"] == "COMPLETED":
            return resp
        if resp["status"] == "FAILED":
            raise Exception(f"Analysis {analysis_id} failed")
        time.sleep(15)
    raise TimeoutError(f"Analysis {analysis_id} timed out")


def analyze_batch(assets: list[dict]) -> list[dict]:
    jobs = []
    for asset in assets:
        job = create_analysis(asset["id"], asset["name"])
        print(f"  Created analysis {job['id']} for {asset['name']}")
        jobs.append({"analysis_id": job["id"], "name": asset["name"]})

    results = []
    for job in jobs:
        result = poll_analysis(job["analysis_id"])
        metrics = result.get("results", {}).get("full_video_metrics", {})
        print(f"  Completed {job['name']}: overall={metrics.get('overall_score')}")
        results.append({"name": job["name"], "analysis_id": job["analysis_id"], "metrics": metrics})
    return results

async function createAnalysis(assetId, label) {
  const resp = await fetch(`${BASE}/video-analyses`, {
    method: "POST", headers: HEADERS,
    body: JSON.stringify({
      title: `Q4 Audit: ${label}`, asset_id: assetId,
      goal: "Score ad effectiveness: engagement, emotion, attention, brand recall, CTA",
      brand: "Brand", product: "Product", primary_intent: "Drive purchase consideration",
      chunk_duration: 5, frames_per_chunk: 3, workspace_id: WORKSPACE_ID,
    }),
  }).then((r) => r.json());
  if (resp.error) throw new Error(resp.error.message);
  return resp;
}

async function pollAnalysis(analysisId, timeoutMin = 20) {
  for (let i = 0; i < timeoutMin * 4; i++) {
    const resp = await fetch(`${BASE}/video-analyses/${analysisId}`, { headers: HEADERS }).then((r) => r.json());
    if (resp.error) throw new Error(resp.error.message);
    if (resp.status === "COMPLETED") return resp;
    if (resp.status === "FAILED") throw new Error(`Analysis ${analysisId} failed`);
    await new Promise((r) => setTimeout(r, 15000));
  }
  throw new Error(`Analysis ${analysisId} timed out`);
}

async function analyzeBatch(assets) {
  const jobs = [];
  for (const asset of assets) {
    const job = await createAnalysis(asset.id, asset.name);
    console.log(`  Created analysis ${job.id} for ${asset.name}`);
    jobs.push({ analysisId: job.id, name: asset.name });
  }
  const results = [];
  for (const job of jobs) {
    const result = await pollAnalysis(job.analysisId);
    const metrics = result.results?.full_video_metrics || {};
    console.log(`  Completed ${job.name}: overall=${metrics.overall_score}`);
    results.push({ name: job.name, analysisId: job.analysisId, metrics });
  }
  return results;
}

def rank_results(results: list[dict]) -> list[dict]:
    ranked = sorted(results, key=lambda r: r["metrics"].get("overall_score", 0), reverse=True)
    for i, r in enumerate(ranked):
        r["rank"] = i + 1
    return ranked


def format_metrics_table(ranked: list[dict]) -> str:
    lines = ["| Rank | Ad | Overall | Emotion | Attention | Brand Recall | CTA |",
             "|------|----|---------|---------|-----------|--------------|----|"]
    for r in ranked:
        m = r["metrics"]
        lines.append(f"| {r['rank']} | {r['name']} | {m.get('overall_score', '—')}/100 "
                      f"| {m.get('emotional_impact', '—')}/10 | {m.get('attention_score', '—')}/10 "
                      f"| {m.get('brand_recall_likelihood', '—')} | {m.get('cta_effectiveness', '—')}/10 |")
    return "\n".join(lines)


def format_chunk_highlights(results: list[dict]) -> str:
    highlights = []
    for r in results:
        chunks = r["metrics"].get("chunks", [])
        if not chunks:
            continue
        best = max(chunks, key=lambda c: c.get("engagement", 0))
        worst = min(chunks, key=lambda c: c.get("engagement", 0))
        highlights.append(f"- **{r['name']}**: peak at {best.get('start_time', '?')}s "
                          f"({best.get('engagement', '?')}), low at {worst.get('start_time', '?')}s "
                          f"({worst.get('engagement', '?')})")
    return "\n".join(highlights)

function rankResults(results) {
  const ranked = [...results].sort((a, b) => (b.metrics.overall_score || 0) - (a.metrics.overall_score || 0));
  ranked.forEach((r, i) => (r.rank = i + 1));
  return ranked;
}

function formatMetricsTable(ranked) {
  const lines = ["| Rank | Ad | Overall | Emotion | Attention | Brand Recall | CTA |",
                  "|------|----|---------|---------|-----------|--------------|----|"];
  for (const r of ranked) {
    const m = r.metrics;
    lines.push(`| ${r.rank} | ${r.name} | ${m.overall_score ?? "—"}/100 ` +
      `| ${m.emotional_impact ?? "—"}/10 | ${m.attention_score ?? "—"}/10 ` +
      `| ${m.brand_recall_likelihood ?? "—"} | ${m.cta_effectiveness ?? "—"}/10 |`);
  }
  return lines.join("\n");
}

function formatChunkHighlights(results) {
  return results.filter((r) => r.metrics.chunks?.length).map((r) => {
    const chunks = r.metrics.chunks;
    const best = chunks.reduce((a, b) => (b.engagement || 0) > (a.engagement || 0) ? b : a);
    const worst = chunks.reduce((a, b) => (b.engagement || 0) < (a.engagement || 0) ? b : a);
    return `- **${r.name}**: peak at ${best.start_time ?? "?"}s (${best.engagement ?? "?"}), low at ${worst.start_time ?? "?"}s (${worst.engagement ?? "?"})`;
  }).join("\n");
}

def generate_audit(ranked: list[dict]) -> str:
    table = format_metrics_table(ranked)
    highlights = format_chunk_highlights(ranked)

    prompt = f"""You are a senior creative strategist conducting a quarterly ad creative audit.

## Ranked Ad Performance
{table}

## Per-Ad Chunk Highlights
{highlights}

## Your Task
Produce a quarterly creative audit:
1. **Executive Summary** — 3-sentence overview of the quarter's creative performance.
2. **Ranked Scorecard** — Table with commentary on each ad's strengths and weaknesses.
3. **Elements to Keep** — Which creative elements (hooks, music, pacing, CTA placement, talent) appear in top ads? Be specific.
4. **Elements to Change** — Which elements correlate with lower scores? Patterns, not individual ads.
5. **Hook Analysis** — Compare the first chunk across all ads. Which opening strategies won?
6. **Brand Recall Deep Dive** — Why did some ads score higher? Logo placement? Early mention?
7. **Recommendations for Next Quarter** — 5 specific, actionable briefs for the creative team.

Cite specific ads by name. Use the scores above as evidence."""

    resp = requests.post(f"{BASE}/mave/chat", headers=HEADERS,
                         json={"message": prompt}, timeout=180).json()
    if "error" in resp:
        raise Exception(resp["error"]["message"])
    return resp["content"]

async function generateAudit(ranked) {
  const table = formatMetricsTable(ranked);
  const highlights = formatChunkHighlights(ranked);

  const prompt = `You are a senior creative strategist conducting a quarterly ad creative audit.

## Ranked Ad Performance
${table}

## Per-Ad Chunk Highlights
${highlights}

## Your Task
Produce a quarterly creative audit:
1. **Executive Summary** — 3-sentence overview.
2. **Ranked Scorecard** — Table with commentary on strengths and weaknesses.
3. **Elements to Keep** — Which creative elements appear in top ads?
4. **Elements to Change** — Which elements correlate with lower scores?
5. **Hook Analysis** — Compare first chunks. Which opening strategies won?
6. **Brand Recall Deep Dive** — Why did some ads score higher?
7. **Recommendations for Next Quarter** — 5 specific briefs for the creative team.

Cite specific ads by name. Use scores as evidence.`;

  const resp = await fetch(`${BASE}/mave/chat`, {
    method: "POST", headers: HEADERS,
    body: JSON.stringify({ message: prompt }), signal: AbortSignal.timeout(180000),
  }).then((r) => r.json());
  if (resp.error) throw new Error(resp.error.message);
  return resp.content;
}

def run_audit(ad_directory: str = "./q4_ads"):
    print("=== Quarterly Ad Creative Audit ===\n")

    print("Stage 1: Uploading videos...")
    assets = upload_all(ad_directory)
    print(f"  Uploaded {len(assets)} ads\n")

    print("Stage 2: Running Video Analysis (batch)...")
    results = analyze_batch(assets)
    print(f"  All {len(results)} analyses complete\n")

    print("Stage 3: Ranking...")
    ranked = rank_results(results)
    print(format_metrics_table(ranked))

    print("\nStage 4: Generating audit with Mave...")
    report = generate_audit(ranked)

    with open("quarterly_creative_audit.md", "w") as f:
        f.write(f"# Quarterly Creative Audit — {time.strftime('%B %Y')}\n\n{report}")
    print("Saved to quarterly_creative_audit.md")
    return ranked, report

if __name__ == "__main__":
    import sys
    run_audit(sys.argv[1] if len(sys.argv) > 1 else "./q4_ads")

async function runAudit(adDirectory = "./q4_ads") {
  console.log("=== Quarterly Ad Creative Audit ===\n");

  console.log("Stage 1: Uploading videos...");
  const assets = await uploadAll(adDirectory);
  console.log(`  Uploaded ${assets.length} ads\n`);

  console.log("Stage 2: Running Video Analysis (batch)...");
  const results = await analyzeBatch(assets);
  console.log(`  All ${results.length} analyses complete\n`);

  console.log("Stage 3: Ranking...");
  const ranked = rankResults(results);
  console.log(formatMetricsTable(ranked));

  console.log("\nStage 4: Generating audit with Mave...");
  const report = await generateAudit(ranked);

  const month = new Date().toLocaleString("default", { month: "long", year: "numeric" });
  fs.writeFileSync("quarterly_creative_audit.md", `# Quarterly Creative Audit — ${month}\n\n${report}`);
  console.log("Saved to quarterly_creative_audit.md");
  return { ranked, report };
}

runAudit(process.argv[2] || "./q4_ads");