Persona Debate

import os, time, json, requests

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

OPPOSING = [
    {"name": "Dana — Budget-Conscious Buyer",
     "role": "Operations Manager at a bootstrapped 30-person startup",
     "description": (
         "Every purchase goes through a personal ROI calculator. Uses free tiers and open-source "
         "before paying. Negotiates every contract. Measures value in dollars saved per hour. "
         "Trusts usage-based pricing over flat fees. Will cancel the moment usage drops below cost."),
     "traits": ["price-sensitive", "ROI-calculator mentality", "free-tier-first",
                "negotiation-driven", "churn-prone if value drops"]},
    {"name": "Victoria — Premium Buyer",
     "role": "VP of Marketing at a Series C company ($30M raised)",
     "description": (
         "Pays significantly more for reliability, support, and time savings. Believes 'you get what you pay for.' "
         "Values white-glove onboarding, dedicated support, and SLAs. Sees price as a quality signal — "
         "if it's too cheap, something must be wrong. Happy to sign annual contracts."),
     "traits": ["quality-over-cost", "time-is-money mentality", "enterprise-expectation",
                "annual-contract-comfortable", "brand-as-signal buyer"]},
]

def create_persona(p):
    resp = requests.post(f"{BASE}/personas", headers=HEADERS, json={
        "name": p["name"], "role": p["role"], "description": p["description"], "traits": p["traits"]})
    resp.raise_for_status()
    data = resp.json()
    print(f"  Created: {data['name']} → {data['id']}")
    return data["id"]

budget_id = create_persona(OPPOSING[0])
premium_id = create_persona(OPPOSING[1])

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

const OPPOSING = [
  { name: "Dana — Budget-Conscious Buyer", role: "Ops Manager, bootstrapped 30-person startup",
    description: "ROI calculator for every purchase. Free tiers first. Negotiates everything. " +
      "Usage-based pricing preferred. Will cancel when value drops below cost.",
    traits: ["price-sensitive", "ROI-calculator mentality", "free-tier-first", "negotiation-driven"] },
  { name: "Victoria — Premium Buyer", role: "VP Marketing, Series C ($30M raised)",
    description: "Pays more for reliability and time savings. 'You get what you pay for.' " +
      "Wants white-glove onboarding and SLAs. Price = quality signal. Annual contracts fine.",
    traits: ["quality-over-cost", "time-is-money", "enterprise-expectation", "brand-as-signal buyer"] },
];

async function createPersona(p) {
  const resp = await fetch(`${BASE}/personas`, { method: "POST", headers: HEADERS,
    body: JSON.stringify({ name: p.name, role: p.role, description: p.description, traits: p.traits }) });
  const data = await resp.json();
  if (data.error) throw new Error(data.error.message);
  return data.id;
}

const budgetId = await createPersona(OPPOSING[0]);
const premiumId = await createPersona(OPPOSING[1]);

PRODUCT = {
    "name": "Mavera Pro",
    "description": "AI-powered audience research. Focus Groups (unlimited), Video Analysis (50/mo), "
                   "Brand Voice, Chat API, Generate, Speak, dedicated Slack support. 5 seats.",
    "features": ["Unlimited Focus Groups", "50 Video Analyses/mo", "Brand Voice extraction",
                 "Chat API", "Generate (all apps)", "Speak conversations", "Dedicated support", "5 seats"],
}

PRICES = [
    {"label": "Starter", "price": "$199/month", "annual": "$1,990/year"},
    {"label": "Growth", "price": "$499/month", "annual": "$4,990/year"},
    {"label": "Scale", "price": "$999/month", "annual": "$9,990/year"},
    {"label": "Enterprise", "price": "$2,499/month", "annual": "$24,990/year"},
]

const PRODUCT = {
  name: "Mavera Pro",
  description: "AI-powered audience research. Focus Groups, Video Analysis, Brand Voice, Chat API, Generate, Speak, support. 5 seats.",
  features: ["Unlimited Focus Groups", "50 Video Analyses/mo", "Brand Voice", "Chat API", "Generate", "Speak", "Support", "5 seats"],
};

const PRICES = [
  { label: "Starter", price: "$199/month", annual: "$1,990/year" },
  { label: "Growth", price: "$499/month", annual: "$4,990/year" },
  { label: "Scale", price: "$999/month", annual: "$9,990/year" },
  { label: "Enterprise", price: "$2,499/month", annual: "$24,990/year" },
];

def build_debate_questions():
    product_block = f"**{PRODUCT['name']}**\n{PRODUCT['description']}\n\n" + "\n".join(f"- {f}" for f in PRODUCT["features"])
    price_block = "\n".join(f"- **{p['label']}**: {p['price']} (annual: {p['annual']})" for p in PRICES)
    return [
        {"question": f"Share your impression of value:\n\n{product_block}", "type": "OPEN_ENDED", "order": 1},
        {"question": f"Which tier would you choose?\n\n{price_block}", "type": "MULTIPLE_CHOICE",
         "options": [f"{p['label']} ({p['price']})" for p in PRICES] + ["None — would not purchase"], "order": 2},
        {"question": "At which price is this 'too expensive' — you'd look for alternatives?", "type": "MULTIPLE_CHOICE",
         "options": [f"{p['label']} ({p['price']})" for p in PRICES] + ["All acceptable"], "order": 3},
        {"question": "At which price is this 'too cheap' — you'd question quality?", "type": "MULTIPLE_CHOICE",
         "options": [f"{p['label']} ({p['price']})" for p in PRICES] + ["None too cheap"], "order": 4},
        {"question": "What features justify the Enterprise tier?", "type": "OPEN_ENDED", "order": 5},
        {"question": "What could be removed to make Starter a fair deal?", "type": "OPEN_ENDED", "order": 6},
        {"question": "If a competitor offered 40% less, would you switch? What prevents it?", "type": "OPEN_ENDED", "order": 7},
        {"question": "Rate overall value at Growth ($499/mo). (0-10)", "type": "NPS", "order": 8},
    ]

def poll_fg(fg_id, timeout_min=10):
    for i in range(timeout_min * 6):
        resp = requests.get(f"{BASE}/focus-groups/{fg_id}", headers=HEADERS).json()
        if "error" in resp: raise Exception(resp["error"]["message"])
        if resp["status"] == "COMPLETED": return resp
        time.sleep(10)
    raise TimeoutError(f"Focus Group {fg_id} timed out")

fg = requests.post(f"{BASE}/focus-groups", headers=HEADERS, json={
    "name": "Persona Debate — Price Positioning",
    "persona_ids": [budget_id, premium_id], "sample_size": 10,
    "questions": build_debate_questions(),
}).json()
print(f"Debate Focus Group: {fg['id']}")
results = poll_fg(fg["id"])

function buildDebateQuestions() {
  const productBlock = `**${PRODUCT.name}**\n${PRODUCT.description}\n\n` + PRODUCT.features.map((f) => `- ${f}`).join("\n");
  const priceBlock = PRICES.map((p) => `- **${p.label}**: ${p.price} (annual: ${p.annual})`).join("\n");
  return [
    { question: `Share your impression:\n\n${productBlock}`, type: "OPEN_ENDED", order: 1 },
    { question: `Which tier?\n\n${priceBlock}`, type: "MULTIPLE_CHOICE",
      options: [...PRICES.map((p) => `${p.label} (${p.price})`), "None — would not purchase"], order: 2 },
    { question: "At which price is this 'too expensive'?", type: "MULTIPLE_CHOICE",
      options: [...PRICES.map((p) => `${p.label} (${p.price})`), "All acceptable"], order: 3 },
    { question: "At which price is this 'too cheap'?", type: "MULTIPLE_CHOICE",
      options: [...PRICES.map((p) => `${p.label} (${p.price})`), "None too cheap"], order: 4 },
    { question: "What features justify Enterprise tier?", type: "OPEN_ENDED", order: 5 },
    { question: "What could be removed for Starter?", type: "OPEN_ENDED", order: 6 },
    { question: "Competitor at 40% less — switch?", type: "OPEN_ENDED", order: 7 },
    { question: "Rate value at Growth ($499/mo). (0-10)", type: "NPS", order: 8 },
  ];
}

async function pollFG(fgId, timeoutMin = 10) {
  for (let i = 0; i < timeoutMin * 6; i++) {
    const resp = await fetch(`${BASE}/focus-groups/${fgId}`, { headers: HEADERS }).then((r) => r.json());
    if (resp.error) throw new Error(resp.error.message);
    if (resp.status === "COMPLETED") return resp;
    await new Promise((r) => setTimeout(r, 10000));
  }
  throw new Error("Timed out");
}

const fg = await fetch(`${BASE}/focus-groups`, { method: "POST", headers: HEADERS,
  body: JSON.stringify({ name: "Persona Debate", persona_ids: [budgetId, premiumId],
    sample_size: 10, questions: buildDebateQuestions() }) }).then((r) => r.json());
const results = await pollFG(fg.id);

def print_debate_report(fg_results):
    print("\n" + "=" * 70)
    print("PERSONA DEBATE — PRICING ANALYSIS")
    print("=" * 70)

    for qr in fg_results.get("results", []):
        print(f"\n{'─' * 60}\nQ: {qr['question'][:75]}\n{'─' * 60}")

        if qr["type"] == "MULTIPLE_CHOICE":
            for opt, cnt in sorted(qr.get("option_counts", {}).items(), key=lambda x: -x[1]):
                print(f"    {opt:45s} {'█' * cnt} ({cnt})")
            budget = [r for r in qr.get("responses", []) if "Budget" in r.get("persona_name", "")]
            premium = [r for r in qr.get("responses", []) if "Premium" in r.get("persona_name", "")]
            if budget:
                choices = [r.get("value", "") for r in budget]
                print(f"\n  Budget tendency: {max(set(choices), key=choices.count)}")
            if premium:
                choices = [r.get("value", "") for r in premium]
                print(f"  Premium tendency: {max(set(choices), key=choices.count)}")

        elif qr["type"] == "NPS":
            print(f"  Overall NPS: {qr.get('nps_score', 'N/A')}")
            for label, keyword in [("Budget", "Budget"), ("Premium", "Premium")]:
                scores = [int(r["value"]) for r in qr.get("responses", [])
                          if keyword in r.get("persona_name", "") and r.get("value") is not None]
                if scores:
                    print(f"  {label} avg: {sum(scores)/len(scores):.1f}/10")

        elif qr["type"] == "OPEN_ENDED":
            print(f"  Summary: {qr.get('summary', 'N/A')}")
            for keyword, label in [("Budget", "Budget"), ("Premium", "Premium")]:
                resps = [r for r in qr.get("responses", []) if keyword in r.get("persona_name", "")]
                if resps:
                    print(f"\n  {label} perspective:")
                    print(f"    \"{resps[0].get('value', '')[:140]}\"")

print_debate_report(results)

function printDebateReport(fgResults) {
  console.log("\n" + "=".repeat(70));
  console.log("PERSONA DEBATE — PRICING ANALYSIS");
  console.log("=".repeat(70));
  for (const qr of fgResults.results || []) {
    console.log(`\n${"─".repeat(60)}\nQ: ${(qr.question || "").slice(0, 75)}\n${"─".repeat(60)}`);
    if (qr.type === "MULTIPLE_CHOICE") {
      for (const [opt, cnt] of Object.entries(qr.option_counts || {}).sort((a, b) => b[1] - a[1]))
        console.log(`    ${opt.padEnd(45)} ${"█".repeat(cnt)} (${cnt})`);
    } else if (qr.type === "NPS") {
      console.log(`  Overall NPS: ${qr.nps_score ?? "N/A"}`);
      for (const kw of ["Budget", "Premium"]) {
        const scores = (qr.responses || []).filter((r) => (r.persona_name || "").includes(kw) && r.value != null);
        if (scores.length) console.log(`  ${kw} avg: ${(scores.reduce((s, r) => s + Number(r.value), 0) / scores.length).toFixed(1)}/10`);
      }
    } else {
      console.log(`  Summary: ${qr.summary || "N/A"}`);
    }
  }
}
printDebateReport(results);

from openai import OpenAI

mavera = OpenAI(api_key=API_KEY, base_url="https://app.mavera.io/api/v1")

def generate_recommendation(fg_results):
    summary = [{"question": qr["question"][:60], "type": qr["type"],
                "summary": qr.get("summary", ""),
                **({"nps": qr.get("nps_score")} if qr["type"] == "NPS" else {}),
                **({"counts": qr.get("option_counts")} if qr["type"] == "MULTIPLE_CHOICE" else {})}
               for qr in fg_results.get("results", [])]

    prices = ", ".join(f"{p['label']}={p['price']}" for p in PRICES)
    resp = mavera.responses.create(model="mavera-1", input=[{"role": "user", "content":
        f"Two opposing buyer personas evaluated this product at these prices: {prices}\n\n"
        f"Results:\n{json.dumps(summary, indent=2)}\n\n"
        "Produce: 1) Van Westendorp interpretation 2) Recommended price point "
        "3) Tier strategy (keep 4 or collapse?) 4) Feature allocation per tier "
        "5) Competitive moat 6) Risk assessment"}])
    return resp.output[0].content[0].text

rec = generate_recommendation(results)
print("\n=== PRICING RECOMMENDATION ===\n")
print(rec)
with open("pricing_debate_report.md", "w") as f:
    f.write(f"# Persona Debate — Pricing Analysis\n\n{rec}")

const OpenAI = require("openai").default;
const mavera = new OpenAI({ apiKey: API_KEY, baseURL: "https://app.mavera.io/api/v1" });

async function generateRecommendation(fgResults) {
  const summary = (fgResults.results || []).map((qr) => ({
    question: (qr.question || "").slice(0, 60), type: qr.type, summary: qr.summary || "",
    ...(qr.type === "NPS" && { nps: qr.nps_score }),
    ...(qr.type === "MULTIPLE_CHOICE" && { counts: qr.option_counts }),
  }));
  const prices = PRICES.map((p) => `${p.label}=${p.price}`).join(", ");
  const resp = await mavera.responses.create({ model: "mavera-1", input: [{ role: "user",
    content: `Two opposing buyers evaluated at: ${prices}\n\n${JSON.stringify(summary, null, 2)}\n\n` +
      "Produce: 1) Van Westendorp 2) Recommended price 3) Tier strategy 4) Feature allocation 5) Moat 6) Risks" }] });
  return resp.output[0].content[0].text;
}
const rec = await generateRecommendation(results);
console.log(rec);
const fs = require("fs");
fs.writeFileSync("pricing_debate_report.md", `# Persona Debate\n\n${rec}`);