Pricing Strategy

#!/usr/bin/env python3
"""Price Increase Modeler - Model revenue impact of price increases at various retention scenarios.

Takes current customer base, pricing, and proposed increase, then projects revenue
impact at multiple retention scenarios with break-even analysis.

Usage:
    python price_increase_modeler.py increase.json
    python price_increase_modeler.py increase.json --format json
"""

import argparse
import json
import sys
from typing import Any


def safe_divide(num: float, den: float, default: float = 0.0) -> float:
    """Safely divide."""
    return num / den if den != 0 else default


def model_increase(data: dict) -> dict:
    """Model a price increase across multiple retention scenarios."""
    current = data.get("current", {})
    proposed = data.get("proposed", {})

    current_price = current.get("price_monthly", 0)
    current_customers = current.get("customer_count", 0)
    current_mrr = current_price * current_customers

    new_price = proposed.get("new_price_monthly", 0)
    increase_pct = safe_divide(new_price - current_price, current_price) * 100

    # Affected vs unaffected customers
    affected_pct = proposed.get("affected_customer_pct", 100) / 100
    affected_customers = int(current_customers * affected_pct)
    unaffected_customers = current_customers - affected_customers

    # Retention scenarios
    retention_rates = proposed.get("retention_scenarios", [100, 95, 90, 85, 80])

    scenarios = []
    for retention_pct in retention_rates:
        retention = retention_pct / 100
        retained_customers = int(affected_customers * retention)
        churned_customers = affected_customers - retained_customers

        # Revenue calculation
        new_mrr_affected = retained_customers * new_price
        new_mrr_unaffected = unaffected_customers * current_price
        new_total_mrr = new_mrr_affected + new_mrr_unaffected

        mrr_change = new_total_mrr - current_mrr
        mrr_change_pct = safe_divide(mrr_change, current_mrr) * 100

        annual_impact = mrr_change * 12

        # Revenue from increase vs revenue lost from churn
        revenue_gained = retained_customers * (new_price - current_price)
        revenue_lost = churned_customers * current_price

        scenario = {
            "retention_pct": retention_pct,
            "retained_customers": retained_customers,
            "churned_customers": churned_customers,
            "new_mrr": round(new_total_mrr, 2),
            "mrr_change": round(mrr_change, 2),
            "mrr_change_pct": round(mrr_change_pct, 2),
            "annual_revenue_impact": round(annual_impact, 2),
            "revenue_gained_from_increase": round(revenue_gained, 2),
            "revenue_lost_from_churn": round(revenue_lost, 2),
            "net_positive": mrr_change > 0,
        }
        scenarios.append(scenario)

    # Break-even calculation
    # At what retention rate does the increase become net-negative?
    # Break-even: retained * new_price = affected * current_price
    # retention_break_even = (affected * current_price) / (affected * new_price)
    if new_price > 0:
        break_even_retention = safe_divide(current_price, new_price) * 100
    else:
        break_even_retention = 0

    # Lock-in offer analysis
    lock_in = proposed.get("lock_in_offer", {})
    lock_in_analysis = None
    if lock_in:
        lock_in_uptake = lock_in.get("expected_uptake_pct", 30) / 100
        lock_in_months = lock_in.get("lock_in_months", 12)
        lock_in_price = lock_in.get("lock_in_price_monthly", current_price)

        locked_customers = int(affected_customers * lock_in_uptake)
        non_locked = affected_customers - locked_customers

        # Revenue during lock-in period
        locked_revenue = locked_customers * lock_in_price * lock_in_months
        # Non-locked face the increase (assume 90% retention)
        non_locked_retained = int(non_locked * 0.9)
        non_locked_revenue = non_locked_retained * new_price * lock_in_months

        total_lock_in_revenue = locked_revenue + non_locked_revenue
        baseline_revenue = affected_customers * current_price * lock_in_months

        lock_in_analysis = {
            "locked_in_customers": locked_customers,
            "lock_in_price": lock_in_price,
            "lock_in_period_months": lock_in_months,
            "revenue_during_lock_in": round(total_lock_in_revenue, 2),
            "baseline_revenue_same_period": round(baseline_revenue, 2),
            "net_impact": round(total_lock_in_revenue - baseline_revenue, 2),
        }

    # Timeline
    timeline = [
        {"week": -12, "action": "Decide strategy, model revenue impact"},
        {"week": -8, "action": "Segment customers by risk (annual, champions, detractors, usage)"},
        {"week": -6, "action": "Prepare communications (email, in-app, FAQ, CS talking points)"},
        {"week": -4, "action": "Announce to existing customers (60+ day notice for annual)"},
        {"week": 0, "action": "New pricing live for new customers"},
        {"week": 4, "action": "Existing customer pricing changes (if not grandfathered)"},
        {"week": 12, "action": "Review: churn rate, downgrade rate, support tickets, revenue"},
    ]

    return {
        "summary": {
            "current_price": current_price,
            "new_price": new_price,
            "increase_pct": round(increase_pct, 1),
            "current_mrr": round(current_mrr, 2),
            "total_customers": current_customers,
            "affected_customers": affected_customers,
            "break_even_retention_pct": round(break_even_retention, 1),
        },
        "scenarios": scenarios,
        "lock_in_analysis": lock_in_analysis,
        "recommended_timeline": timeline,
    }


def format_text(result: dict) -> str:
    """Format model results as human-readable text."""
    lines = []
    s = result["summary"]

    lines.append("=" * 60)
    lines.append("PRICE INCREASE IMPACT MODEL")
    lines.append("=" * 60)
    lines.append("")
    lines.append(f"Current Price:     ${s['current_price']:>10,.2f}/mo")
    lines.append(f"New Price:         ${s['new_price']:>10,.2f}/mo  (+{s['increase_pct']}%)")
    lines.append(f"Current MRR:       ${s['current_mrr']:>10,.2f}")
    lines.append(f"Total Customers:   {s['total_customers']:>10,}")
    lines.append(f"Affected:          {s['affected_customers']:>10,}")
    lines.append(f"Break-even:        {s['break_even_retention_pct']:>10.1f}% retention")
    lines.append("")

    lines.append("-" * 60)
    lines.append("RETENTION SCENARIOS")
    lines.append("-" * 60)
    lines.append(f"{'Retention':<12} {'New MRR':>12} {'MRR Change':>14} {'Annual':>14} {'Net?':>8}")
    lines.append("-" * 60)
    for sc in result["scenarios"]:
        net = "+" if sc["net_positive"] else "-"
        lines.append(
            f"{sc['retention_pct']:>6}%      "
            f"${sc['new_mrr']:>10,.2f} "
            f"${sc['mrr_change']:>+12,.2f} "
            f"${sc['annual_revenue_impact']:>+12,.2f} "
            f"  {net}"
        )

    lines.append("")
    for sc in result["scenarios"]:
        if not sc["net_positive"]:
            lines.append(f"  >> Net-negative below {sc['retention_pct']+5}% retention")
            break

    if result.get("lock_in_analysis"):
        li = result["lock_in_analysis"]
        lines.append("")
        lines.append("-" * 40)
        lines.append("LOCK-IN OFFER ANALYSIS")
        lines.append("-" * 40)
        lines.append(f"  Customers who lock in:  {li['locked_in_customers']:,}")
        lines.append(f"  Lock-in price:          ${li['lock_in_price']:,.2f}/mo for {li['lock_in_period_months']} months")
        lines.append(f"  Revenue during period:  ${li['revenue_during_lock_in']:,.2f}")
        lines.append(f"  Baseline same period:   ${li['baseline_revenue_same_period']:,.2f}")
        lines.append(f"  Net impact:             ${li['net_impact']:+,.2f}")

    lines.append("")
    lines.append("-" * 40)
    lines.append("RECOMMENDED TIMELINE")
    lines.append("-" * 40)
    for step in result["recommended_timeline"]:
        week = step["week"]
        prefix = f"Week {week:+d}" if week != 0 else "Week 0 "
        lines.append(f"  {prefix:>10}: {step['action']}")

    lines.append("")
    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Model revenue impact of price increases at various retention scenarios."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with price increase scenario data",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = model_increase(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Price Sensitivity Calculator - Van Westendorp Price Sensitivity Meter implementation.

Takes survey responses for the four Van Westendorp questions and calculates:
optimal price point, indifference price, acceptable range, and point of marginal
cheapness/expensiveness.

Usage:
    python price_sensitivity_calculator.py survey.json
    python price_sensitivity_calculator.py survey.json --format json
"""

import argparse
import json
import sys
from typing import Any


def calculate_cumulative_distribution(values: list[float], price_points: list[float], ascending: bool = True) -> list[float]:
    """Calculate cumulative distribution at each price point.

    Args:
        values: Raw survey responses (price values from respondents).
        price_points: The set of price points to evaluate.
        ascending: If True, cumulative from low to high (% who said this or less).
                   If False, cumulative from high to low (% who said this or more).

    Returns:
        List of cumulative percentages (0-100) at each price point.
    """
    n = len(values)
    if n == 0:
        return [0.0] * len(price_points)

    sorted_vals = sorted(values)
    result = []

    for pp in price_points:
        if ascending:
            count = sum(1 for v in sorted_vals if v <= pp)
        else:
            count = sum(1 for v in sorted_vals if v >= pp)
        result.append((count / n) * 100)

    return result


def find_intersection(x_points: list[float], y1: list[float], y2: list[float]) -> float | None:
    """Find approximate intersection point of two curves using linear interpolation."""
    for i in range(len(x_points) - 1):
        diff1 = y1[i] - y2[i]
        diff2 = y1[i + 1] - y2[i + 1]

        if diff1 == 0:
            return x_points[i]
        if diff2 == 0:
            return x_points[i + 1]

        # Sign change indicates intersection
        if (diff1 > 0 and diff2 < 0) or (diff1 < 0 and diff2 > 0):
            # Linear interpolation
            t = diff1 / (diff1 - diff2)
            return x_points[i] + t * (x_points[i + 1] - x_points[i])

    return None


def analyze_sensitivity(data: dict) -> dict:
    """Run Van Westendorp price sensitivity analysis."""
    responses = data.get("responses", [])

    if len(responses) < 10:
        return {"error": f"Need at least 10 responses for valid analysis (got {len(responses)}). Recommended: 30+."}

    # Extract the four price arrays
    too_cheap = [r["too_cheap"] for r in responses if "too_cheap" in r]
    bargain = [r["bargain"] for r in responses if "bargain" in r]
    expensive = [r["expensive"] for r in responses if "expensive" in r]
    too_expensive = [r["too_expensive"] for r in responses if "too_expensive" in r]

    if not all([too_cheap, bargain, expensive, too_expensive]):
        return {"error": "Each response must have: too_cheap, bargain, expensive, too_expensive"}

    # Validate ordering within each response
    validation_issues = []
    for i, r in enumerate(responses):
        if not all(k in r for k in ["too_cheap", "bargain", "expensive", "too_expensive"]):
            continue
        if not (r["too_cheap"] <= r["bargain"] <= r["expensive"] <= r["too_expensive"]):
            validation_issues.append(f"Response {i+1}: prices not in expected order (too_cheap <= bargain <= expensive <= too_expensive)")

    # Generate price points for analysis
    all_prices = too_cheap + bargain + expensive + too_expensive
    min_price = min(all_prices)
    max_price = max(all_prices)

    # Create fine-grained price points
    step = max((max_price - min_price) / 200, 0.01)
    price_points = []
    p = min_price
    while p <= max_price:
        price_points.append(round(p, 2))
        p += step

    # Calculate cumulative distributions
    # "Too cheap" - % who said this price or HIGHER is too cheap (descending)
    too_cheap_cum = calculate_cumulative_distribution(too_cheap, price_points, ascending=False)
    # "Bargain" - % who said this price or HIGHER is a bargain (descending)
    bargain_cum = calculate_cumulative_distribution(bargain, price_points, ascending=False)
    # "Expensive" - % who said this price or LOWER is expensive (ascending)
    expensive_cum = calculate_cumulative_distribution(expensive, price_points, ascending=True)
    # "Too expensive" - % who said this price or LOWER is too expensive (ascending)
    too_expensive_cum = calculate_cumulative_distribution(too_expensive, price_points, ascending=True)

    # Find key intersection points
    # OPP (Optimal Price Point): intersection of "too cheap" and "too expensive"
    opp = find_intersection(price_points, too_cheap_cum, too_expensive_cum)

    # IDP (Indifference Price Point): intersection of "bargain" and "expensive"
    idp = find_intersection(price_points, bargain_cum, expensive_cum)

    # PMC (Point of Marginal Cheapness): intersection of "too cheap" and "expensive"
    pmc = find_intersection(price_points, too_cheap_cum, expensive_cum)

    # PME (Point of Marginal Expensiveness): intersection of "bargain" and "too expensive"
    pme = find_intersection(price_points, bargain_cum, too_expensive_cum)

    # Summary statistics
    summary_stats = {
        "respondent_count": len(responses),
        "too_cheap_median": round(sorted(too_cheap)[len(too_cheap) // 2], 2),
        "bargain_median": round(sorted(bargain)[len(bargain) // 2], 2),
        "expensive_median": round(sorted(expensive)[len(expensive) // 2], 2),
        "too_expensive_median": round(sorted(too_expensive)[len(too_expensive) // 2], 2),
    }

    # Recommendations
    recommendations = []
    if opp:
        recommendations.append(f"Optimal Price Point (OPP): ${opp:.2f} -- the price that maximizes the number of buyers while minimizing resistance")
    if pmc and pme:
        recommendations.append(f"Acceptable Price Range: ${pmc:.2f} to ${pme:.2f} -- pricing outside this range risks losing significant market share")
    if idp:
        recommendations.append(f"Indifference Price Point: ${idp:.2f} -- equal number of respondents find this cheap vs expensive")

    if opp and pmc and pme:
        if pmc <= opp <= pme:
            recommendations.append("OPP falls within the acceptable range -- pricing model is viable")
        else:
            recommendations.append("WARNING: OPP falls outside the acceptable range -- review survey data quality")

    return {
        "key_price_points": {
            "optimal_price_point": round(opp, 2) if opp else None,
            "indifference_price_point": round(idp, 2) if idp else None,
            "point_of_marginal_cheapness": round(pmc, 2) if pmc else None,
            "point_of_marginal_expensiveness": round(pme, 2) if pme else None,
            "acceptable_range": {
                "low": round(pmc, 2) if pmc else None,
                "high": round(pme, 2) if pme else None,
            },
        },
        "summary_stats": summary_stats,
        "recommendations": recommendations,
        "validation_issues": validation_issues[:5],  # Cap at 5
        "methodology": "Van Westendorp Price Sensitivity Meter (4-question model)",
    }


def format_text(result: dict) -> str:
    """Format analysis as human-readable text."""
    lines = []

    if "error" in result:
        return f"Error: {result['error']}"

    lines.append("=" * 60)
    lines.append("VAN WESTENDORP PRICE SENSITIVITY ANALYSIS")
    lines.append("=" * 60)
    lines.append("")

    kp = result["key_price_points"]
    lines.append("-" * 40)
    lines.append("KEY PRICE POINTS")
    lines.append("-" * 40)
    lines.append(f"  Optimal Price Point (OPP):      ${kp['optimal_price_point']:>8.2f}" if kp["optimal_price_point"] else "  Optimal Price Point: Could not be calculated")
    lines.append(f"  Indifference Price (IDP):        ${kp['indifference_price_point']:>8.2f}" if kp["indifference_price_point"] else "  Indifference Price: Could not be calculated")
    lines.append(f"  Marginal Cheapness (PMC):        ${kp['point_of_marginal_cheapness']:>8.2f}" if kp["point_of_marginal_cheapness"] else "  Marginal Cheapness: Could not be calculated")
    lines.append(f"  Marginal Expensiveness (PME):    ${kp['point_of_marginal_expensiveness']:>8.2f}" if kp["point_of_marginal_expensiveness"] else "  Marginal Expensiveness: Could not be calculated")

    ar = kp.get("acceptable_range", {})
    if ar.get("low") and ar.get("high"):
        lines.append(f"\n  ACCEPTABLE RANGE: ${ar['low']:.2f} - ${ar['high']:.2f}")
    lines.append("")

    ss = result["summary_stats"]
    lines.append("-" * 40)
    lines.append(f"SURVEY SUMMARY ({ss['respondent_count']} respondents)")
    lines.append("-" * 40)
    lines.append(f"  Too Cheap median:      ${ss['too_cheap_median']:>8.2f}")
    lines.append(f"  Bargain median:        ${ss['bargain_median']:>8.2f}")
    lines.append(f"  Expensive median:      ${ss['expensive_median']:>8.2f}")
    lines.append(f"  Too Expensive median:  ${ss['too_expensive_median']:>8.2f}")
    lines.append("")

    if result["recommendations"]:
        lines.append("-" * 40)
        lines.append("RECOMMENDATIONS")
        lines.append("-" * 40)
        for rec in result["recommendations"]:
            lines.append(f"  - {rec}")
        lines.append("")

    if result["validation_issues"]:
        lines.append("-" * 40)
        lines.append("VALIDATION WARNINGS")
        lines.append("-" * 40)
        for vi in result["validation_issues"]:
            lines.append(f"  - {vi}")

    lines.append("")
    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Van Westendorp Price Sensitivity Meter calculator."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with Van Westendorp survey responses",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_sensitivity(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Pricing Model Analyzer - Evaluate SaaS pricing model against best practices.

Analyzes value metric alignment, tier architecture, feature allocation, pricing
signals, and anti-patterns. Outputs a health scorecard with prioritized recommendations.

Usage:
    python pricing_model_analyzer.py pricing.json
    python pricing_model_analyzer.py pricing.json --format json
"""

import argparse
import json
import sys
from typing import Any


VALID_VALUE_METRICS = [
    "per_seat", "per_usage", "per_feature", "flat_fee", "per_outcome", "hybrid",
]

ENTERPRISE_FEATURES = [
    "sso", "scim", "audit_logs", "sla", "dedicated_support",
    "custom_integrations", "api_access", "advanced_security",
]

TIER_COUNT_GUIDANCE = {
    1: {"rating": "Poor", "issue": "Single tier provides no upsell path or anchoring"},
    2: {"rating": "Fair", "issue": "Two tiers lack the anchoring effect of Good-Better-Best"},
    3: {"rating": "Excellent", "issue": None},
    4: {"rating": "Good", "issue": "Four tiers acceptable but verify differentiation is clear"},
}


def safe_divide(num: float, den: float, default: float = 0.0) -> float:
    """Safely divide."""
    return num / den if den != 0 else default


def analyze_value_metric(data: dict) -> dict:
    """Analyze value metric selection."""
    metric = data.get("value_metric", "")
    issues = []
    score = 0

    if not metric:
        return {"score": 0, "issues": ["No value metric defined"], "metric": "unknown"}

    if metric not in VALID_VALUE_METRICS:
        issues.append(f"Unknown value metric: {metric}")
    else:
        score += 20

    # Check if metric scales with value
    if data.get("scales_with_customer_value", False):
        score += 30
    else:
        issues.append("Value metric may not scale with customer success -- review if larger customers pay proportionally more")

    # Check if metric is easy to understand
    if data.get("metric_easy_to_understand", True):
        score += 25
    else:
        issues.append("Complex value metric reduces conversion -- simplify or explain clearly on pricing page")

    # Check for gaming risk
    if data.get("metric_gameable", False):
        score -= 15
        issues.append("Value metric can be gamed by customers (e.g., shared seats, artificial usage reduction)")

    # Red flag checks
    if metric == "per_seat" and data.get("single_power_user_common", False):
        issues.append("Per-seat pricing with single power user pattern -- seats do not scale with value; consider usage-based")
        score -= 10

    if metric == "flat_fee" and data.get("usage_varies_10x", False):
        issues.append("Flat fee with 10x usage variance subsidizes heavy users -- add usage tiers or hybrid model")
        score -= 10

    return {"score": min(max(score, 0), 100), "issues": issues, "metric": metric}


def analyze_tiers(data: dict) -> dict:
    """Analyze tier architecture."""
    tiers = data.get("tiers", [])
    issues = []
    score = 0

    tier_count = len(tiers)

    # Tier count
    guidance = TIER_COUNT_GUIDANCE.get(tier_count)
    if guidance:
        if guidance["issue"]:
            issues.append(guidance["issue"])
        if guidance["rating"] in ("Excellent", "Good"):
            score += 30
        elif guidance["rating"] == "Fair":
            score += 15
    elif tier_count > 4:
        score += 10
        issues.append(f"{tier_count} tiers is too many -- simplify to 3-4 (3-4 tiers outperform 5+ in conversion)")
    elif tier_count == 0:
        return {"score": 0, "issues": ["No tiers defined"], "tier_analysis": []}

    # Price jumps between tiers
    tier_analysis = []
    for i, tier in enumerate(tiers):
        tier_info = {
            "name": tier.get("name", f"Tier {i+1}"),
            "price": tier.get("price_monthly", 0),
            "features": tier.get("features", []),
        }

        if i > 0:
            prev_price = tiers[i-1].get("price_monthly", 0)
            if prev_price > 0:
                multiplier = safe_divide(tier.get("price_monthly", 0), prev_price)
                tier_info["price_multiplier"] = round(multiplier, 1)
                if multiplier < 1.5:
                    issues.append(f"{tier_info['name']} is only {multiplier:.1f}x previous tier -- target 2-3x jumps")
                elif multiplier > 5:
                    issues.append(f"{tier_info['name']} is {multiplier:.1f}x previous tier -- large gap may lose mid-market customers")
                else:
                    score += 10

        tier_analysis.append(tier_info)

    # Enterprise features check (top tier)
    if tiers:
        top_tier = tiers[-1]
        top_features = [f.lower() for f in top_tier.get("features", [])]
        missing_enterprise = []
        for ef in ENTERPRISE_FEATURES:
            if not any(ef in f for f in top_features):
                missing_enterprise.append(ef)

        if missing_enterprise and tier_count >= 3:
            issues.append(f"Top tier missing enterprise features: {', '.join(missing_enterprise[:4])}")
        else:
            score += 15

    # Recommended plan highlight
    has_recommended = any(t.get("is_recommended", False) for t in tiers)
    if not has_recommended and tier_count >= 3:
        issues.append("No tier marked as 'recommended' -- highlight the middle tier to anchor purchasing decisions")
    elif has_recommended:
        score += 10

    return {"score": min(max(score, 0), 100), "issues": issues, "tier_analysis": tier_analysis}


def analyze_pricing_signals(data: dict) -> dict:
    """Analyze pricing health signals."""
    signals = data.get("signals", {})
    issues = []
    diagnostics = []

    trial_conversion = signals.get("trial_to_paid_pct")
    if trial_conversion is not None:
        if trial_conversion > 40:
            diagnostics.append({"signal": "Trial-to-paid > 40%", "diagnosis": "Likely underpriced", "action": "Test 20-30% increase"})
        elif 15 <= trial_conversion <= 30:
            diagnostics.append({"signal": f"Trial-to-paid {trial_conversion}%", "diagnosis": "Healthy range", "action": "Optimize packaging, not price"})
        elif trial_conversion < 10:
            diagnostics.append({"signal": f"Trial-to-paid {trial_conversion}%", "diagnosis": "Possibly overpriced or activation issue", "action": "Investigate whether price or trial experience is the problem"})

    monthly_churn = signals.get("monthly_churn_pct")
    if monthly_churn is not None and monthly_churn > 5:
        diagnostics.append({"signal": f"Monthly churn {monthly_churn}%", "diagnosis": "Fix churn before pricing changes", "action": "Use churn-prevention skill first"})

    years_since_change = signals.get("years_since_price_change")
    if years_since_change is not None and years_since_change >= 2:
        diagnostics.append({"signal": f"Price unchanged for {years_since_change} years", "diagnosis": "Inflation alone justifies 10-15%", "action": "Plan a price increase"})

    annual_adoption = signals.get("annual_plan_adoption_pct")
    if annual_adoption is not None and annual_adoption < 40:
        diagnostics.append({"signal": f"Annual adoption {annual_adoption}%", "diagnosis": "Annual plan underperforming", "action": "Default toggle to annual, show savings prominently ('Save 20%' or '2 months free')"})

    return {"diagnostics": diagnostics, "issues": issues}


def analyze_pricing(data: dict) -> dict:
    """Run full pricing model analysis."""
    vm_result = analyze_value_metric(data)
    tier_result = analyze_tiers(data)
    signal_result = analyze_pricing_signals(data)

    # Overall score
    overall_score = int((vm_result["score"] + tier_result["score"]) / 2)

    all_issues = vm_result["issues"] + tier_result["issues"] + signal_result["issues"]

    if overall_score >= 75:
        rating = "Healthy"
    elif overall_score >= 50:
        rating = "Needs Optimization"
    elif overall_score >= 25:
        rating = "Significant Issues"
    else:
        rating = "Critical"

    return {
        "summary": {
            "overall_score": overall_score,
            "rating": rating,
            "total_issues": len(all_issues),
            "value_metric": vm_result["metric"],
            "tier_count": len(data.get("tiers", [])),
        },
        "value_metric_analysis": vm_result,
        "tier_analysis": tier_result,
        "pricing_signals": signal_result,
        "all_issues": all_issues,
    }


def format_text(result: dict) -> str:
    """Format analysis as human-readable text."""
    lines = []
    s = result["summary"]

    lines.append("=" * 60)
    lines.append("PRICING MODEL ANALYSIS")
    lines.append("=" * 60)
    lines.append("")
    lines.append(f"Overall Score: {s['overall_score']}/100  ({s['rating']})")
    lines.append(f"Value Metric: {s['value_metric']}")
    lines.append(f"Tiers: {s['tier_count']}")
    lines.append(f"Issues Found: {s['total_issues']}")
    lines.append("")

    # Value metric
    vm = result["value_metric_analysis"]
    lines.append("-" * 40)
    lines.append(f"VALUE METRIC ({vm['score']}/100)")
    lines.append("-" * 40)
    for issue in vm["issues"]:
        lines.append(f"  - {issue}")
    if not vm["issues"]:
        lines.append("  No issues found.")
    lines.append("")

    # Tiers
    ta = result["tier_analysis"]
    lines.append("-" * 40)
    lines.append(f"TIER ARCHITECTURE ({ta['score']}/100)")
    lines.append("-" * 40)
    for tier in ta.get("tier_analysis", []):
        mult = f" ({tier['price_multiplier']}x prev)" if "price_multiplier" in tier else ""
        lines.append(f"  {tier['name']}: ${tier['price']:,.0f}/mo{mult}")
    lines.append("")
    for issue in ta["issues"]:
        lines.append(f"  - {issue}")
    lines.append("")

    # Signals
    ps = result["pricing_signals"]
    if ps["diagnostics"]:
        lines.append("-" * 40)
        lines.append("PRICING SIGNALS")
        lines.append("-" * 40)
        for diag in ps["diagnostics"]:
            lines.append(f"\n  Signal: {diag['signal']}")
            lines.append(f"  Diagnosis: {diag['diagnosis']}")
            lines.append(f"  Action: {diag['action']}")
    lines.append("")

    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Analyze SaaS pricing model against best practices."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with pricing model configuration",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_pricing(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()