Market Entry Research

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"]
TARGET_MARKET = os.environ.get(
    "TARGET_MARKET",
    "B2B cybersecurity compliance for mid-market SaaS",
)

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,
)

RESEARCH_PROMPTS = [
    {
        "pillar": "competitive_landscape",
        "prompt": (
            f"We're considering entering the {TARGET_MARKET} space. "
            "Research the competitive landscape:\n"
            "- Who are the top 5-10 players? (name, estimated market share, funding stage)\n"
            "- What positioning does each competitor use?\n"
            "- What are their pricing models?\n"
            "- Any recent M&A, funding rounds, or pivots?\n"
            "- Where are the gaps in the market that no one is addressing well?\n\n"
            "Cite your sources."
        ),
    },
    {
        "pillar": "regulatory_environment",
        "prompt": (
            "Now research the regulatory environment for this market:\n"
            "- What compliance frameworks apply (SOC 2, ISO 27001, GDPR, HIPAA, etc.)?\n"
            "- Are there licensing or certification requirements?\n"
            "- What pending legislation could impact this market in the next 12-24 months?\n"
            "- Are there geographic variations (US vs EU vs APAC)?\n"
            "- What are the compliance costs and timelines for a new entrant?\n\n"
            "Cite your sources."
        ),
    },
    {
        "pillar": "buyer_personas",
        "prompt": (
            "Based on what you've found about the competitive and regulatory landscape, "
            "research the typical buyers in this market:\n"
            "- What are the primary buyer titles and roles?\n"
            "- What budget range and authority do they have?\n"
            "- What are their top 3-5 pain points?\n"
            "- What decision criteria do they use when evaluating solutions?\n"
            "- What does their buying process look like (stages, timeline, stakeholders)?\n"
            "- Are there distinct buyer segments (enterprise vs mid-market vs SMB)?\n\n"
            "Cite your sources."
        ),
    },
    {
        "pillar": "gtm_strategies",
        "prompt": (
            "Given the competitive landscape, regulatory environment, and buyer profiles "
            "you've researched, recommend go-to-market strategies:\n"
            "- What channels are most effective for reaching these buyers?\n"
            "- Are there partnership or integration opportunities?\n"
            "- What pricing strategy would work (freemium, usage-based, seat-based, etc.)?\n"
            "- What should the launch sequence look like (beta → GA → expansion)?\n"
            "- What content and thought leadership topics would establish credibility?\n"
            "- How long until first revenue, and what's a realistic first-year target?\n\n"
            "Base your recommendations on the specific market context, not generic advice."
        ),
    },
    {
        "pillar": "risks_and_barriers",
        "prompt": (
            "Finally, identify the top risks and barriers to entry:\n"
            "- What switching costs exist for buyers using incumbent solutions?\n"
            "- Are there network effects or lock-in that favor incumbents?\n"
            "- What regulatory barriers could slow or block entry?\n"
            "- What timing risks exist (market maturity, economic conditions)?\n"
            "- What technical moats do incumbents have (data, integrations, patents)?\n"
            "- What would cause this market entry to fail?\n\n"
            "Rank risks by severity (high/medium/low) and likelihood."
        ),
    },
]


def run_research_thread() -> dict:
    """Run all 5 research turns in a single Mave thread."""
    thread_id = None
    research = {}

    for turn in RESEARCH_PROMPTS:
        payload = {"message": turn["prompt"]}
        if thread_id:
            payload["thread_id"] = thread_id

        resp = requests.post(
            f"{BASE}/mave/chat",
            headers=HEADERS,
            json=payload,
            timeout=120,
        ).json()

        if "error" in resp:
            raise Exception(f"Mave error on {turn['pillar']}: {resp['error']['message']}")

        if not thread_id:
            thread_id = resp.get("thread_id")

        research[turn["pillar"]] = {
            "content": resp.get("content", ""),
            "sources": resp.get("sources", []),
        }

        print(f"✓ {turn['pillar']} — {len(resp.get('content', ''))} chars, "
              f"{len(resp.get('sources', []))} sources")

        time.sleep(2)

    return {"thread_id": thread_id, "pillars": research}

BRIEF_SCHEMA = {"type": "json_schema", "json_schema": {
    "name": "market_entry_brief", "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "market": {"type": "string", "description": "Target market name"},
            "executive_summary": {"type": "string", "description": "3-5 sentence executive summary"},
            "market_size_estimate": {"type": "string", "description": "TAM/SAM/SOM if available"},
            "top_competitors": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "positioning": {"type": "string"},
                        "estimated_share": {"type": "string"},
                        "weakness": {"type": "string"},
                    },
                    "required": ["name", "positioning", "estimated_share", "weakness"],
                },
                "description": "Top 5 competitors",
            },
            "regulatory_requirements": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Key compliance frameworks and requirements",
            },
            "primary_buyer": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "budget_range": {"type": "string"},
                    "top_pain_points": {"type": "array", "items": {"type": "string"}},
                    "decision_criteria": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["title", "budget_range", "top_pain_points", "decision_criteria"],
            },
            "recommended_gtm": {
                "type": "object",
                "properties": {
                    "pricing_model": {"type": "string"},
                    "primary_channel": {"type": "string"},
                    "launch_sequence": {"type": "string"},
                    "time_to_revenue": {"type": "string"},
                },
                "required": ["pricing_model", "primary_channel", "launch_sequence", "time_to_revenue"],
            },
            "top_risks": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "risk": {"type": "string"},
                        "severity": {"type": "string"},
                        "mitigation": {"type": "string"},
                    },
                    "required": ["risk", "severity", "mitigation"],
                },
            },
            "go_no_go_recommendation": {"type": "string", "description": "Go, No-Go, or Conditional Go with reasoning"},
        },
        "required": [
            "market", "executive_summary", "market_size_estimate",
            "top_competitors", "regulatory_requirements", "primary_buyer",
            "recommended_gtm", "top_risks", "go_no_go_recommendation",
        ],
    },
}}


def structure_brief(research: dict) -> dict:
    """Convert raw Mave research into a structured market entry brief."""
    combined = "\n\n".join(
        f"## {pillar.replace('_', ' ').title()}\n{data['content']}"
        for pillar, data in research["pillars"].items()
    )

    resp = mavera.responses.create(
        model="mavera-1",
        input=[{
            "role": "user",
            "content": (
                f"Synthesize this market research into a structured market entry brief "
                f"for the {TARGET_MARKET} market.\n\n"
                f"Include a Go / No-Go / Conditional Go recommendation with reasoning.\n\n"
                f"{combined}"
            ),
        }],
        extra_body={"response_format": BRIEF_SCHEMA},
    )

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

def drill_down(thread_id: str, question: str) -> dict:
    """Ask a follow-up question within the existing research thread."""
    resp = requests.post(
        f"{BASE}/mave/chat",
        headers=HEADERS,
        json={
            "thread_id": thread_id,
            "message": question,
        },
        timeout=120,
    ).json()

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


DRILL_DOWN_QUESTIONS = [
    "What specific integrations do the top 3 competitors offer? Which ecosystem partnerships give them the strongest moat?",
    "For the mid-market segment specifically, what's the typical evaluation timeline and who else is involved in the buying committee?",
    "Are there any open-source or low-cost alternatives gaining traction that could disrupt the market from below?",
]

def run_pipeline():
    print(f"Researching: {TARGET_MARKET}")
    print("=" * 60)

    # Stage 1: Research
    print("\n--- Stage 1: Mave Research Thread ---")
    research = run_research_thread()
    print(f"\nThread ID: {research['thread_id']}")
    print(f"Pillars researched: {len(research['pillars'])}")

    total_sources = sum(
        len(p["sources"]) for p in research["pillars"].values()
    )
    print(f"Total sources cited: {total_sources}")

    # Stage 2: Structure
    print("\n--- Stage 2: Structuring Brief ---")
    brief = structure_brief(research)
    print(f"Market: {brief['market']}")
    print(f"Competitors identified: {len(brief['top_competitors'])}")
    print(f"Risks identified: {len(brief['top_risks'])}")
    print(f"Recommendation: {brief['go_no_go_recommendation'][:100]}...")

    # Stage 3: Drill-down (optional)
    print("\n--- Stage 3: Drill-Down Questions ---")
    drill_downs = {}
    for q in DRILL_DOWN_QUESTIONS:
        result = drill_down(research["thread_id"], q)
        drill_downs[q[:50]] = result.get("content", "")
        print(f"✓ {q[:60]}...")
        time.sleep(2)

    # Save outputs
    with open("market_entry_brief.json", "w") as f:
        json.dump(brief, f, indent=2)

    raw_report = f"# Market Entry Brief: {TARGET_MARKET}\n\n"
    raw_report += f"## Executive Summary\n{brief['executive_summary']}\n\n"
    raw_report += f"## Market Size\n{brief['market_size_estimate']}\n\n"
    raw_report += "## Competitive Landscape\n"
    for comp in brief["top_competitors"]:
        raw_report += f"- **{comp['name']}**: {comp['positioning']} (share: {comp['estimated_share']}, weakness: {comp['weakness']})\n"
    raw_report += f"\n## Recommendation\n{brief['go_no_go_recommendation']}\n"

    with open("market_entry_report.md", "w") as f:
        f.write(raw_report)

    print("\n✓ Saved market_entry_brief.json")
    print("✓ Saved market_entry_report.md")
    return brief


if __name__ == "__main__":
    run_pipeline()