Brand Perception Audit

import os
import json
import time
import requests
from openai import OpenAI

MAVERA_API_KEY = os.environ["MAVERA_API_KEY"]
WORKSPACE_ID = os.environ["MAVERA_WORKSPACE_ID"]
BRAND_NAME = os.environ.get("BRAND_NAME", "Acme")
BASE = "https://app.mavera.io/api/v1"
HEADERS = {
    "Authorization": f"Bearer {MAVERA_API_KEY}",
    "Content-Type": "application/json",
}
mavera = OpenAI(api_key=MAVERA_API_KEY, base_url=BASE)

BRAND_CONTEXT = {
    "name": BRAND_NAME,
    "category": "AI-powered market research platform",
    "value_prop": "replacing guesswork with persona-validated audience insights",
    "competitors": ["Pollfish", "UserTesting", "Wynter", "SurveyMonkey"],
}

SEGMENTS = {
    "customers": {
        "label": "Current Customers",
        "personas": [
            {
                "name": f"{BRAND_NAME} Power User — Growth Marketer",
                "description": (
                    f"Active {BRAND_NAME} user for 6+ months. Uses focus groups and chat weekly. "
                    "Growth marketer at a Series B startup. Loves the speed but occasionally "
                    "questions depth compared to real research. NPS likely 7-9."
                ),
            },
            {
                "name": f"{BRAND_NAME} Casual User — Content Manager",
                "description": (
                    f"Uses {BRAND_NAME} 2-3 times a month for content scoring. "
                    "Content manager at a mid-market company. Finds it useful but hasn't "
                    "explored beyond basic chat. Might not renew if price increases. NPS likely 6-7."
                ),
            },
            {
                "name": f"{BRAND_NAME} Champion — VP Marketing",
                "description": (
                    f"Internally champions {BRAND_NAME}. VP Marketing who got the team adopted. "
                    "Uses it for positioning workshops and campaign validation. "
                    "Would recommend to peers. NPS likely 9-10."
                ),
            },
        ],
    },
    "prospects": {
        "label": "Prospects (Evaluating)",
        "personas": [
            {
                "name": f"{BRAND_NAME} Prospect — Skeptical PMM",
                "description": (
                    f"Aware of {BRAND_NAME} but hasn't tried it. Product marketer at an enterprise "
                    "company. Skeptical about synthetic audiences replacing real research. "
                    "Currently uses agencies and UserTesting. Needs proof of accuracy."
                ),
            },
            {
                "name": f"{BRAND_NAME} Prospect — Budget-Conscious Founder",
                "description": (
                    f"Heard about {BRAND_NAME} from a peer. Founder at a seed-stage startup. "
                    "Interested in the concept but worried about cost and whether AI research "
                    "is credible enough for investor presentations."
                ),
            },
        ],
    },
    "churned": {
        "label": "Churned Users",
        "personas": [
            {
                "name": f"Former {BRAND_NAME} User — Price Churned",
                "description": (
                    f"Used {BRAND_NAME} for 3 months, then cancelled citing cost. "
                    "Marketing coordinator at a small company. Found the tool useful but "
                    "couldn't justify the monthly cost for occasional use. Went back to "
                    "Google Forms and informal feedback."
                ),
            },
            {
                "name": f"Former {BRAND_NAME} User — Depth Churned",
                "description": (
                    f"Used {BRAND_NAME} for 6 months at an enterprise company. Cancelled because "
                    "leadership didn't trust synthetic research for high-stakes decisions. "
                    "Felt the personas lacked nuance compared to real interviews. "
                    "Switched to a traditional research agency."
                ),
            },
        ],
    },
}

import OpenAI from "openai";

const MAVERA_API_KEY = process.env.MAVERA_API_KEY;
const WORKSPACE_ID = process.env.MAVERA_WORKSPACE_ID;
const BRAND_NAME = process.env.BRAND_NAME || "Acme";
const BASE = "https://app.mavera.io/api/v1";
const HEADERS = {
  Authorization: `Bearer ${MAVERA_API_KEY}`,
  "Content-Type": "application/json",
};
const mavera = new OpenAI({ apiKey: MAVERA_API_KEY, baseURL: BASE });

const BRAND_CONTEXT = {
  name: BRAND_NAME,
  category: "AI-powered market research platform",
  value_prop: "replacing guesswork with persona-validated audience insights",
  competitors: ["Pollfish", "UserTesting", "Wynter", "SurveyMonkey"],
};

const SEGMENTS = {
  customers: {
    label: "Current Customers",
    personas: [
      {
        name: `${BRAND_NAME} Power User — Growth Marketer`,
        description:
          `Active ${BRAND_NAME} user for 6+ months. Uses focus groups and chat weekly. ` +
          "Growth marketer at a Series B startup. Loves the speed.",
      },
      {
        name: `${BRAND_NAME} Casual User — Content Manager`,
        description:
          `Uses ${BRAND_NAME} 2-3 times a month for content scoring. ` +
          "Content manager at a mid-market company. Might not renew if price increases.",
      },
      {
        name: `${BRAND_NAME} Champion — VP Marketing`,
        description:
          `Internally champions ${BRAND_NAME}. VP Marketing who got the team adopted. ` +
          "Would recommend to peers. NPS likely 9-10.",
      },
    ],
  },
  prospects: {
    label: "Prospects (Evaluating)",
    personas: [
      {
        name: `${BRAND_NAME} Prospect — Skeptical PMM`,
        description:
          `Aware of ${BRAND_NAME} but hasn't tried it. Product marketer at an enterprise company. ` +
          "Skeptical about synthetic audiences replacing real research.",
      },
      {
        name: `${BRAND_NAME} Prospect — Budget-Conscious Founder`,
        description:
          `Heard about ${BRAND_NAME} from a peer. Founder at a seed-stage startup. ` +
          "Worried about cost and credibility for investor presentations.",
      },
    ],
  },
  churned: {
    label: "Churned Users",
    personas: [
      {
        name: `Former ${BRAND_NAME} User — Price Churned`,
        description:
          `Used ${BRAND_NAME} for 3 months, then cancelled citing cost. ` +
          "Marketing coordinator at a small company. Went back to Google Forms.",
      },
      {
        name: `Former ${BRAND_NAME} User — Depth Churned`,
        description:
          `Used ${BRAND_NAME} for 6 months at an enterprise company. Cancelled because ` +
          "leadership didn't trust synthetic research for high-stakes decisions.",
      },
    ],
  },
};

def create_segment_personas() -> dict[str, list[str]]:
    """Create personas for all 3 segments. Returns {segment_key: [persona_ids]}."""
    segment_ids = {}

    for segment_key, segment in SEGMENTS.items():
        ids = []
        for persona in segment["personas"]:
            resp = requests.post(
                f"{BASE}/personas",
                headers=HEADERS,
                json={
                    "name": persona["name"],
                    "description": persona["description"],
                    "workspace_id": WORKSPACE_ID,
                },
            ).json()

            if "error" in resp:
                raise Exception(f"Failed: {persona['name']}: {resp['error']['message']}")

            ids.append(resp["id"])
            print(f"✓ [{segment['label']}] {persona['name']} ({resp['id']})")

        segment_ids[segment_key] = ids

    total = sum(len(v) for v in segment_ids.values())
    print(f"\nCreated {total} personas across {len(segment_ids)} segments")
    return segment_ids

async function createSegmentPersonas() {
  const segmentIds = {};

  for (const [segmentKey, segment] of Object.entries(SEGMENTS)) {
    const ids = [];
    for (const persona of segment.personas) {
      const resp = await fetch(`${BASE}/personas`, {
        method: "POST",
        headers: HEADERS,
        body: JSON.stringify({
          name: persona.name,
          description: persona.description,
          workspace_id: WORKSPACE_ID,
        }),
      }).then((r) => r.json());

      if (resp.error) throw new Error(`Failed: ${persona.name}: ${resp.error.message}`);
      ids.push(resp.id);
      console.log(`✓ [${segment.label}] ${persona.name} (${resp.id})`);
    }
    segmentIds[segmentKey] = ids;
  }

  return segmentIds;
}

def build_question_battery() -> list[dict]:
    """Build the standard 6-question perception battery."""
    return [
        {
            "question": (
                f"How likely are you to recommend {BRAND_NAME} to a colleague or peer? "
                f"(0 = not at all likely, 10 = extremely likely)"
            ),
            "type": "NPS",
            "order": 1,
        },
        {
            "question": (
                f"What 3 words or phrases come to mind when you think of {BRAND_NAME}? "
                f"Explain why each word applies."
            ),
            "type": "OPEN_ENDED",
            "order": 2,
        },
        {
            "question": f"Rate {BRAND_NAME} on trustworthiness:",
            "type": "SEMANTIC_DIFFERENTIAL",
            "left_anchor": "Untrustworthy / unreliable",
            "right_anchor": "Trustworthy / dependable",
            "scale": 7,
            "order": 3,
        },
        {
            "question": f"Rate {BRAND_NAME} on innovation:",
            "type": "SEMANTIC_DIFFERENTIAL",
            "left_anchor": "Outdated / behind the curve",
            "right_anchor": "Innovative / cutting-edge",
            "scale": 7,
            "order": 4,
        },
        {
            "question": (
                f"How well does {BRAND_NAME} deliver on its promise of "
                f"'{BRAND_CONTEXT['value_prop']}'? Rate 1-10."
            ),
            "type": "LIKERT",
            "scale": 10,
            "order": 5,
        },
        {
            "question": (
                f"What is the biggest risk of choosing {BRAND_NAME} over alternatives "
                f"like {', '.join(BRAND_CONTEXT['competitors'][:3])}? "
                f"What concerns would make you hesitate?"
            ),
            "type": "OPEN_ENDED",
            "order": 6,
        },
    ]


def run_segment_focus_groups(segment_ids: dict) -> dict:
    """Launch one focus group per segment. Returns {segment_key: fg_response}."""
    questions = build_question_battery()
    focus_groups = {}

    for segment_key, persona_ids in segment_ids.items():
        label = SEGMENTS[segment_key]["label"]

        payload = {
            "name": f"Brand Perception Audit — {label}",
            "sample_size": 25,
            "persona_ids": persona_ids,
            "workspace_id": WORKSPACE_ID,
            "questions": questions,
        }

        resp = requests.post(
            f"{BASE}/focus-groups",
            headers=HEADERS,
            json=payload,
        ).json()

        if "error" in resp:
            raise Exception(f"Failed [{label}]: {resp['error']['message']}")

        focus_groups[segment_key] = resp
        print(f"✓ Focus group launched: {label} ({resp['id']})")

    return focus_groups


def poll_all_focus_groups(focus_groups: dict, timeout_min: int = 15) -> dict:
    """Poll all focus groups until they complete."""
    results = {}
    pending = dict(focus_groups)

    for attempt in range(timeout_min * 6):
        for segment_key, fg in list(pending.items()):
            resp = requests.get(
                f"{BASE}/focus-groups/{fg['id']}",
                headers=HEADERS,
            ).json()

            if "error" in resp:
                raise Exception(resp["error"]["message"])

            if resp.get("status") == "COMPLETED":
                results[segment_key] = resp
                del pending[segment_key]
                label = SEGMENTS[segment_key]["label"]
                print(f"✓ {label} completed")

            elif resp.get("status") == "FAILED":
                raise Exception(f"Focus group {fg['id']} failed")

        if not pending:
            print(f"\nAll {len(results)} focus groups completed")
            return results

        time.sleep(10)

    raise TimeoutError(f"{len(pending)} focus groups did not complete")

function buildQuestionBattery() {
  return [
    {
      question: `How likely are you to recommend ${BRAND_NAME} to a colleague? (0-10)`,
      type: "NPS", order: 1,
    },
    {
      question: `What 3 words come to mind when you think of ${BRAND_NAME}? Explain.`,
      type: "OPEN_ENDED", order: 2,
    },
    {
      question: `Rate ${BRAND_NAME} on trustworthiness:`,
      type: "SEMANTIC_DIFFERENTIAL",
      left_anchor: "Untrustworthy / unreliable",
      right_anchor: "Trustworthy / dependable",
      scale: 7, order: 3,
    },
    {
      question: `Rate ${BRAND_NAME} on innovation:`,
      type: "SEMANTIC_DIFFERENTIAL",
      left_anchor: "Outdated / behind the curve",
      right_anchor: "Innovative / cutting-edge",
      scale: 7, order: 4,
    },
    {
      question:
        `How well does ${BRAND_NAME} deliver on its promise of ` +
        `'${BRAND_CONTEXT.value_prop}'? Rate 1-10.`,
      type: "LIKERT", scale: 10, order: 5,
    },
    {
      question:
        `What is the biggest risk of choosing ${BRAND_NAME} over ` +
        `${BRAND_CONTEXT.competitors.slice(0, 3).join(", ")}?`,
      type: "OPEN_ENDED", order: 6,
    },
  ];
}

async function runSegmentFocusGroups(segmentIds) {
  const questions = buildQuestionBattery();
  const focusGroups = {};

  for (const [segmentKey, personaIds] of Object.entries(segmentIds)) {
    const label = SEGMENTS[segmentKey].label;
    const resp = await fetch(`${BASE}/focus-groups`, {
      method: "POST", headers: HEADERS,
      body: JSON.stringify({
        name: `Brand Perception Audit — ${label}`,
        sample_size: 25, persona_ids: personaIds,
        workspace_id: WORKSPACE_ID, questions,
      }),
    }).then((r) => r.json());

    if (resp.error) throw new Error(`Failed [${label}]: ${resp.error.message}`);
    focusGroups[segmentKey] = resp;
    console.log(`✓ Focus group launched: ${label} (${resp.id})`);
  }
  return focusGroups;
}

async function pollAllFocusGroups(focusGroups, timeoutMin = 15) {
  const results = {};
  const pending = { ...focusGroups };

  for (let i = 0; i < timeoutMin * 6; i++) {
    for (const [key, fg] of Object.entries(pending)) {
      const resp = await fetch(`${BASE}/focus-groups/${fg.id}`, {
        headers: HEADERS,
      }).then((r) => r.json());

      if (resp.error) throw new Error(resp.error.message);
      if (resp.status === "COMPLETED") {
        results[key] = resp;
        delete pending[key];
        console.log(`✓ ${SEGMENTS[key].label} completed`);
      }
    }
    if (Object.keys(pending).length === 0) return results;
    await new Promise((r) => setTimeout(r, 10000));
  }
  throw new Error("Focus groups timed out");
}

def compare_segments(all_results: dict) -> dict:
    """Extract and compare key metrics across segments."""
    comparison = {}

    for segment_key, fg_results in all_results.items():
        label = SEGMENTS[segment_key]["label"]
        segment_data = {"label": label, "nps": None, "trust": None, "innovation": None, "promise_delivery": None, "word_associations": [], "perceived_risks": []}

        for result in fg_results.get("results", []):
            q_type = result.get("type")

            if q_type == "NPS":
                segment_data["nps"] = {
                    "score": result.get("nps_score"),
                    "promoters": result.get("promoter_count", 0),
                    "passives": result.get("passive_count", 0),
                    "detractors": result.get("detractor_count", 0),
                    "summary": result.get("summary", ""),
                }

            elif q_type == "SEMANTIC_DIFFERENTIAL":
                question = result.get("question", "")
                if "trustworthiness" in question.lower():
                    segment_data["trust"] = result.get("mean_score", 0)
                elif "innovation" in question.lower():
                    segment_data["innovation"] = result.get("mean_score", 0)

            elif q_type == "LIKERT":
                segment_data["promise_delivery"] = result.get("mean_score", 0)

            elif q_type == "OPEN_ENDED":
                question = result.get("question", "")
                if "3 words" in question.lower():
                    segment_data["word_associations"] = result.get("themes", [])
                elif "risk" in question.lower():
                    segment_data["perceived_risks"] = result.get("themes", [])

        comparison[segment_key] = segment_data

    return comparison


def print_comparison(comparison: dict):
    """Print a comparison table."""
    print("\n" + "=" * 70)
    print("CROSS-SEGMENT BRAND PERCEPTION COMPARISON")
    print("=" * 70)

    header = f"{'Metric':<25}"
    for data in comparison.values():
        header += f"{data['label']:<20}"
    print(header)
    print("-" * 70)

    # NPS
    row = f"{'NPS Score':<25}"
    for data in comparison.values():
        nps = data["nps"]["score"] if data["nps"] else "N/A"
        row += f"{nps:<20}"
    print(row)

    # Trust
    row = f"{'Trust (1-7)':<25}"
    for data in comparison.values():
        row += f"{data['trust'] or 'N/A':<20}"
    print(row)

    # Innovation
    row = f"{'Innovation (1-7)':<25}"
    for data in comparison.values():
        row += f"{data['innovation'] or 'N/A':<20}"
    print(row)

    # Promise delivery
    row = f"{'Promise Delivery (1-10)':<25}"
    for data in comparison.values():
        row += f"{data['promise_delivery'] or 'N/A':<20}"
    print(row)

    # Word associations
    print(f"\n{'Word Associations:':<25}")
    for data in comparison.values():
        words = ", ".join(data["word_associations"][:5]) if data["word_associations"] else "N/A"
        print(f"  {data['label']}: {words}")

    # Perceived risks
    print(f"\n{'Perceived Risks:':<25}")
    for data in comparison.values():
        risks = data["perceived_risks"][:3] if data["perceived_risks"] else ["N/A"]
        print(f"  {data['label']}:")
        for risk in risks:
            print(f"    • {risk}")

function compareSegments(allResults) {
  const comparison = {};

  for (const [segmentKey, fgResults] of Object.entries(allResults)) {
    const label = SEGMENTS[segmentKey].label;
    const data = {
      label, nps: null, trust: null, innovation: null,
      promise_delivery: null, word_associations: [], perceived_risks: [],
    };

    for (const result of fgResults.results || []) {
      if (result.type === "NPS") {
        data.nps = {
          score: result.nps_score,
          promoters: result.promoter_count || 0,
          passives: result.passive_count || 0,
          detractors: result.detractor_count || 0,
        };
      } else if (result.type === "SEMANTIC_DIFFERENTIAL") {
        if (result.question?.toLowerCase().includes("trustworthiness"))
          data.trust = result.mean_score || 0;
        else if (result.question?.toLowerCase().includes("innovation"))
          data.innovation = result.mean_score || 0;
      } else if (result.type === "LIKERT") {
        data.promise_delivery = result.mean_score || 0;
      } else if (result.type === "OPEN_ENDED") {
        if (result.question?.toLowerCase().includes("3 words"))
          data.word_associations = result.themes || [];
        else if (result.question?.toLowerCase().includes("risk"))
          data.perceived_risks = result.themes || [];
      }
    }
    comparison[segmentKey] = data;
  }
  return comparison;
}

function printComparison(comparison) {
  console.log("\nCROSS-SEGMENT BRAND PERCEPTION COMPARISON");
  for (const [key, data] of Object.entries(comparison)) {
    console.log(`\n${data.label}:`);
    console.log(`  NPS: ${data.nps?.score ?? "N/A"}`);
    console.log(`  Trust: ${data.trust ?? "N/A"}/7`);
    console.log(`  Innovation: ${data.innovation ?? "N/A"}/7`);
    console.log(`  Promise Delivery: ${data.promise_delivery ?? "N/A"}/10`);
  }
}

REPORT_SCHEMA = {"type": "json_schema", "json_schema": {
    "name": "brand_perception_report", "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "executive_summary": {"type": "string"},
            "overall_brand_health": {"type": "string", "description": "Strong, Moderate, Weak, or Critical"},
            "nps_comparison": {
                "type": "object",
                "properties": {
                    "customers": {"type": "number"},
                    "prospects": {"type": "number"},
                    "churned": {"type": "number"},
                    "gap_analysis": {"type": "string"},
                },
                "required": ["customers", "prospects", "churned", "gap_analysis"],
            },
            "perception_gaps": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "dimension": {"type": "string"},
                        "gap_description": {"type": "string"},
                        "severity": {"type": "string"},
                        "recommendation": {"type": "string"},
                    },
                    "required": ["dimension", "gap_description", "severity", "recommendation"],
                },
            },
            "brand_strengths": {"type": "array", "items": {"type": "string"}},
            "brand_weaknesses": {"type": "array", "items": {"type": "string"}},
            "churn_drivers": {"type": "array", "items": {"type": "string"}},
            "prospect_barriers": {"type": "array", "items": {"type": "string"}},
            "priority_actions": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "action": {"type": "string"},
                        "impact": {"type": "string"},
                        "effort": {"type": "string"},
                        "timeline": {"type": "string"},
                    },
                    "required": ["action", "impact", "effort", "timeline"],
                },
            },
        },
        "required": [
            "executive_summary", "overall_brand_health", "nps_comparison",
            "perception_gaps", "brand_strengths", "brand_weaknesses",
            "churn_drivers", "prospect_barriers", "priority_actions",
        ],
    },
}}


def generate_perception_report(comparison: dict) -> dict:
    """Synthesize a 360-degree brand perception report."""
    prompt = (
        f"You are a brand strategist. Analyze this 360-degree brand perception data "
        f"for {BRAND_NAME} ({BRAND_CONTEXT['category']}) and produce a comprehensive report.\n\n"
        f"Value proposition: '{BRAND_CONTEXT['value_prop']}'\n"
        f"Competitors: {', '.join(BRAND_CONTEXT['competitors'])}\n\n"
        f"## Cross-Segment Data\n{json.dumps(comparison, indent=2)}\n\n"
        "Focus on:\n"
        "1. How perception differs across customers, prospects, and churned users\n"
        "2. The biggest perception gaps and their business impact\n"
        "3. What's driving churn from a brand perception standpoint\n"
        "4. What's blocking prospect conversion\n"
        "5. Prioritized actions to improve brand health"
    )

    resp = mavera.responses.create(
        model="mavera-1",
        input=[{"role": "user", "content": prompt}],
        extra_body={"response_format": REPORT_SCHEMA},
    )

    return json.loads(resp.output[0].content[0].text)

const REPORT_SCHEMA = { type: "json_schema", json_schema: {
  name: "brand_perception_report", strict: true,
  schema: {
    type: "object",
    properties: {
      executive_summary: { type: "string" },
      overall_brand_health: { type: "string" },
      nps_comparison: {
        type: "object",
        properties: {
          customers: { type: "number" }, prospects: { type: "number" },
          churned: { type: "number" }, gap_analysis: { type: "string" },
        },
        required: ["customers", "prospects", "churned", "gap_analysis"],
      },
      perception_gaps: {
        type: "array",
        items: {
          type: "object",
          properties: {
            dimension: { type: "string" }, gap_description: { type: "string" },
            severity: { type: "string" }, recommendation: { type: "string" },
          },
          required: ["dimension", "gap_description", "severity", "recommendation"],
        },
      },
      brand_strengths: { type: "array", items: { type: "string" } },
      brand_weaknesses: { type: "array", items: { type: "string" } },
      churn_drivers: { type: "array", items: { type: "string" } },
      prospect_barriers: { type: "array", items: { type: "string" } },
      priority_actions: {
        type: "array",
        items: {
          type: "object",
          properties: {
            action: { type: "string" }, impact: { type: "string" },
            effort: { type: "string" }, timeline: { type: "string" },
          },
          required: ["action", "impact", "effort", "timeline"],
        },
      },
    },
    required: [
      "executive_summary", "overall_brand_health", "nps_comparison",
      "perception_gaps", "brand_strengths", "brand_weaknesses",
      "churn_drivers", "prospect_barriers", "priority_actions",
    ],
  },
}};

async function generatePerceptionReport(comparison) {
  const prompt =
    `You are a brand strategist. Analyze this 360-degree brand perception data ` +
    `for ${BRAND_NAME} (${BRAND_CONTEXT.category}).\n\n` +
    `Value proposition: '${BRAND_CONTEXT.value_prop}'\n\n` +
    `## Cross-Segment Data\n${JSON.stringify(comparison, null, 2)}\n\n` +
    "Focus on perception gaps, churn drivers, prospect barriers, and prioritized actions.";

  const resp = await mavera.responses.create({
    model: "mavera-1",
    input: [{ role: "user", content: prompt }],
    response_format: REPORT_SCHEMA,
  });

  return JSON.parse(resp.output[0].content[0].text);
}

def run_brand_audit():
    print("=" * 60)
    print(f"BRAND PERCEPTION AUDIT — {BRAND_NAME}")
    print("=" * 60)

    # Stage 1: Create personas
    print("\n--- Stage 1: Creating Segment Personas ---")
    segment_ids = create_segment_personas()

    # Stage 2: Run focus groups
    print("\n--- Stage 2: Running 3 Focus Groups ---")
    focus_groups = run_segment_focus_groups(segment_ids)
    all_results = poll_all_focus_groups(focus_groups)

    # Stage 3: Compare
    print("\n--- Stage 3: Cross-Segment Comparison ---")
    comparison = compare_segments(all_results)
    print_comparison(comparison)

    # Stage 4: Report
    print("\n--- Stage 4: Generating 360° Report ---")
    report = generate_perception_report(comparison)

    print(f"\nBrand Health: {report['overall_brand_health']}")
    print(f"NPS — Customers: {report['nps_comparison']['customers']}, "
          f"Prospects: {report['nps_comparison']['prospects']}, "
          f"Churned: {report['nps_comparison']['churned']}")

    print(f"\nStrengths:")
    for s in report["brand_strengths"]:
        print(f"  + {s}")
    print(f"\nWeaknesses:")
    for w in report["brand_weaknesses"]:
        print(f"  - {w}")

    print(f"\nPriority Actions:")
    for action in report["priority_actions"]:
        print(f"  [{action['impact']} impact, {action['effort']} effort] {action['action']}")

    # Save
    output = {"comparison": comparison, "report": report}
    with open("brand_perception_audit.json", "w") as f:
        json.dump(output, f, indent=2)

    print("\n✓ Saved brand_perception_audit.json")
    return report


if __name__ == "__main__":
    run_brand_audit()

import fs from "fs";

async function runBrandAudit() {
  console.log(`BRAND PERCEPTION AUDIT — ${BRAND_NAME}`);

  const segmentIds = await createSegmentPersonas();
  const focusGroups = await runSegmentFocusGroups(segmentIds);
  const allResults = await pollAllFocusGroups(focusGroups);

  const comparison = compareSegments(allResults);
  printComparison(comparison);

  const report = await generatePerceptionReport(comparison);

  console.log(`\nBrand Health: ${report.overall_brand_health}`);
  console.log(`NPS — Customers: ${report.nps_comparison.customers}, ` +
    `Prospects: ${report.nps_comparison.prospects}, Churned: ${report.nps_comparison.churned}`);

  fs.writeFileSync("brand_perception_audit.json", JSON.stringify({ comparison, report }, null, 2));
  console.log("\n✓ Saved brand_perception_audit.json");
  return report;
}

runBrandAudit();