Form Cro

#!/usr/bin/env python3
"""
A/B Test Calculator

Calculate A/B test sample size, duration, and statistical significance
for form optimization experiments. Uses standard statistical formulas
for two-proportion z-test.

Usage:
    python ab_test_calculator.py --baseline 25 --lift 10 --traffic 500
    python ab_test_calculator.py --baseline 25 --lift 10 --traffic 500 --json
"""

import argparse
import json
import math
import sys


def norm_ppf(p: float) -> float:
    """Approximate inverse normal CDF (percent-point function).

    Uses Abramowitz and Stegun approximation 26.2.23.
    Accurate to ~4.5e-4 for 0 < p < 1.
    """
    if p <= 0 or p >= 1:
        return 0.0

    if p < 0.5:
        sign = -1
        p = 1 - p
    else:
        sign = 1
        p = p

    t = math.sqrt(-2.0 * math.log(1.0 - p))

    # Rational approximation
    c0 = 2.515517
    c1 = 0.802853
    c2 = 0.010328
    d1 = 1.432788
    d2 = 0.189269
    d3 = 0.001308

    numerator = c0 + c1 * t + c2 * t * t
    denominator = 1.0 + d1 * t + d2 * t * t + d3 * t * t * t

    result = sign * (t - numerator / denominator)
    return result


def calculate_sample_size(baseline_rate: float, min_detectable_lift: float,
                          confidence: float = 0.95, power: float = 0.80) -> int:
    """Calculate required sample size per variant.

    Uses the formula for two-proportion z-test:
    n = (Z_alpha/2 + Z_beta)^2 * (p1(1-p1) + p2(1-p2)) / (p2 - p1)^2
    """
    p1 = baseline_rate / 100.0
    relative_lift = min_detectable_lift / 100.0
    p2 = p1 * (1 + relative_lift)

    if p2 >= 1.0:
        p2 = 0.99
    if p1 == p2:
        return 0

    alpha = 1 - confidence
    z_alpha = norm_ppf(1 - alpha / 2)
    z_beta = norm_ppf(power)

    numerator = (z_alpha + z_beta) ** 2 * (p1 * (1 - p1) + p2 * (1 - p2))
    denominator = (p2 - p1) ** 2

    if denominator == 0:
        return 0

    n = math.ceil(numerator / denominator)
    return n


def calculate_test(baseline: float, lift: float, daily_traffic: int,
                   confidence: float) -> dict:
    """Calculate complete A/B test plan."""
    sample_per_variant = calculate_sample_size(baseline, lift, confidence / 100.0)
    total_sample = sample_per_variant * 2

    # Duration calculation
    traffic_per_variant = daily_traffic / 2  # Split traffic
    if traffic_per_variant > 0:
        days_needed = math.ceil(sample_per_variant / traffic_per_variant)
    else:
        days_needed = float('inf')

    # Minimum 14 days for business cycle coverage
    days_needed = max(14, days_needed)
    weeks_needed = math.ceil(days_needed / 7)

    # Expected conversion rates
    expected_variant_rate = baseline * (1 + lift / 100.0)

    # Conversions needed
    min_conversions_per_variant = max(200, math.ceil(sample_per_variant * (baseline / 100.0)))

    # Risk assessment
    if daily_traffic < 100:
        traffic_risk = "HIGH -- low traffic may require 2+ months"
    elif daily_traffic < 500:
        traffic_risk = "MEDIUM -- adequate for testing major changes"
    else:
        traffic_risk = "LOW -- sufficient traffic for reliable results"

    # Alternative lift scenarios
    lift_scenarios = []
    for alt_lift in [5, 10, 15, 20, 25, 30]:
        alt_sample = calculate_sample_size(baseline, alt_lift, confidence / 100.0)
        alt_days = max(14, math.ceil(alt_sample / max(1, traffic_per_variant)))
        lift_scenarios.append({
            "lift_pct": alt_lift,
            "sample_per_variant": alt_sample,
            "days_needed": alt_days,
            "weeks_needed": math.ceil(alt_days / 7),
        })

    return {
        "inputs": {
            "baseline_rate_pct": baseline,
            "minimum_detectable_lift_pct": lift,
            "daily_traffic": daily_traffic,
            "confidence_level_pct": confidence,
            "statistical_power_pct": 80,
        },
        "test_plan": {
            "sample_per_variant": sample_per_variant,
            "total_sample_needed": total_sample,
            "days_needed": days_needed,
            "weeks_needed": weeks_needed,
            "min_conversions_per_variant": min_conversions_per_variant,
            "expected_variant_rate_pct": round(expected_variant_rate, 2),
        },
        "traffic_assessment": {
            "daily_traffic": daily_traffic,
            "traffic_per_variant": int(traffic_per_variant),
            "risk_level": traffic_risk,
        },
        "lift_scenarios": lift_scenarios,
        "recommendations": _generate_recommendations(days_needed, daily_traffic, lift, baseline),
    }


def _generate_recommendations(days: int, traffic: int, lift: float, baseline: float) -> list:
    """Generate test recommendations."""
    recs = []

    if days > 60:
        recs.append({
            "priority": "HIGH",
            "recommendation": f"Test requires {days} days. Consider testing a bigger change (higher expected lift) to reduce required sample size.",
        })

    if traffic < 200:
        recs.append({
            "priority": "HIGH",
            "recommendation": "Low daily traffic. Focus on high-impact changes (field removal, CTA rewrite) rather than subtle tweaks.",
        })

    if lift < 10:
        recs.append({
            "priority": "MEDIUM",
            "recommendation": "Detecting small lifts requires large samples. Test bigger changes or accept a higher minimum detectable lift.",
        })

    recs.append({
        "priority": "MEDIUM",
        "recommendation": "Run test for full business cycles (minimum 2 weeks). Avoid ending on weekends or holidays.",
    })

    recs.append({
        "priority": "MEDIUM",
        "recommendation": f"Track downstream metrics (lead quality, SQL rate) not just form completion rate. A test that increases quantity but decreases quality is not a win.",
    })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append("A/B TEST CALCULATOR")
    lines.append("=" * 60)

    inp = result["inputs"]
    lines.append(f"\nBaseline Rate:      {inp['baseline_rate_pct']:>8.1f}%")
    lines.append(f"Min Detectable Lift:{inp['minimum_detectable_lift_pct']:>8.1f}%")
    lines.append(f"Daily Traffic:      {inp['daily_traffic']:>8d}")
    lines.append(f"Confidence:         {inp['confidence_level_pct']:>8.0f}%")
    lines.append(f"Power:              {inp['statistical_power_pct']:>8d}%")

    tp = result["test_plan"]
    lines.append(f"\n--- Test Plan ---")
    lines.append(f"Sample per Variant:   {tp['sample_per_variant']:>8,d}")
    lines.append(f"Total Sample Needed:  {tp['total_sample_needed']:>8,d}")
    lines.append(f"Days Needed:          {tp['days_needed']:>8d}")
    lines.append(f"Weeks Needed:         {tp['weeks_needed']:>8d}")
    lines.append(f"Expected Variant Rate:{tp['expected_variant_rate_pct']:>8.2f}%")

    ta = result["traffic_assessment"]
    lines.append(f"\n--- Traffic Assessment ---")
    lines.append(f"Risk Level: {ta['risk_level']}")

    lines.append(f"\n--- Lift Scenarios ---")
    lines.append(f"{'Lift':>6}  {'Sample/Var':>12}  {'Days':>6}  {'Weeks':>6}")
    for s in result["lift_scenarios"]:
        lines.append(f"{s['lift_pct']:>5d}%  {s['sample_per_variant']:>12,d}  {s['days_needed']:>6d}  {s['weeks_needed']:>6d}")

    lines.append(f"\n--- Recommendations ---")
    for r in result["recommendations"]:
        lines.append(f"[{r['priority']}] {r['recommendation']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Calculate A/B test sample size, duration, and statistical significance."
    )
    parser.add_argument("--baseline", type=float, required=True,
                        help="Current conversion rate as percentage (e.g., 25 for 25%%)")
    parser.add_argument("--lift", type=float, required=True,
                        help="Minimum detectable lift as percentage (e.g., 10 for 10%% relative lift)")
    parser.add_argument("--traffic", type=int, required=True,
                        help="Daily traffic (visitors per day)")
    parser.add_argument("--confidence", type=float, default=95,
                        help="Confidence level as percentage (default: 95)")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    if args.baseline <= 0 or args.baseline >= 100:
        print("Error: --baseline must be between 0 and 100.", file=sys.stderr)
        sys.exit(1)
    if args.lift <= 0:
        print("Error: --lift must be positive.", file=sys.stderr)
        sys.exit(1)
    if args.traffic <= 0:
        print("Error: --traffic must be positive.", file=sys.stderr)
        sys.exit(1)

    result = calculate_test(args.baseline, args.lift, args.traffic, args.confidence)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Field Cost Analyzer

Calculate the estimated abandonment cost of each form field and recommend
fields to remove, keep, or enrich post-submission. Includes dollar impact
estimation based on traffic and lead value.

Usage:
    python field_cost_analyzer.py form_fields.json
    python field_cost_analyzer.py form_fields.json --monthly-visitors 5000 --current-rate 30 --value-per-lead 100
    python field_cost_analyzer.py form_fields.json --json
"""

import argparse
import json
import sys


FIELD_COSTS = {
    "email": {"drop_pct": 1, "enrichable": False, "category": "essential"},
    "first_name": {"drop_pct": 3, "enrichable": False, "category": "standard"},
    "last_name": {"drop_pct": 3, "enrichable": False, "category": "standard"},
    "full_name": {"drop_pct": 2, "enrichable": False, "category": "standard"},
    "phone": {"drop_pct": 8, "enrichable": False, "category": "high_friction"},
    "company": {"drop_pct": 4, "enrichable": True, "category": "enrichable"},
    "company_size": {"drop_pct": 4, "enrichable": True, "category": "enrichable"},
    "job_title": {"drop_pct": 4, "enrichable": True, "category": "enrichable"},
    "industry": {"drop_pct": 3, "enrichable": True, "category": "enrichable"},
    "message": {"drop_pct": 6, "enrichable": False, "category": "high_friction"},
    "textarea": {"drop_pct": 6, "enrichable": False, "category": "high_friction"},
    "budget": {"drop_pct": 10, "enrichable": False, "category": "high_friction"},
    "website": {"drop_pct": 3, "enrichable": True, "category": "enrichable"},
    "country": {"drop_pct": 2, "enrichable": True, "category": "enrichable"},
    "dropdown": {"drop_pct": 3, "enrichable": False, "category": "standard"},
    "checkbox": {"drop_pct": 1, "enrichable": False, "category": "low_friction"},
    "radio": {"drop_pct": 2, "enrichable": False, "category": "low_friction"},
    "custom": {"drop_pct": 4, "enrichable": False, "category": "standard"},
}


def analyze_fields(data: dict, monthly_visitors: int, current_rate: float,
                   value_per_lead: float) -> dict:
    """Analyze form fields for abandonment cost."""
    fields = data.get("fields", [])
    if not fields:
        return {"error": "No field data provided."}

    current_leads = monthly_visitors * (current_rate / 100.0)
    current_monthly_value = current_leads * value_per_lead

    field_results = []
    cumulative_drop = 0

    for f in fields:
        ftype = f.get("type", "custom").lower()
        label = f.get("label", ftype)
        required = f.get("required", True)

        cost_data = FIELD_COSTS.get(ftype, FIELD_COSTS["custom"])
        drop_pct = cost_data["drop_pct"]
        enrichable = cost_data["enrichable"]
        category = cost_data["category"]

        if not required:
            drop_pct = max(1, drop_pct // 2)

        cumulative_drop += drop_pct

        # Dollar impact of this field
        leads_lost = monthly_visitors * (drop_pct / 100.0)
        dollar_impact = leads_lost * value_per_lead

        if enrichable and required:
            action = "REMOVE -- enrichable post-submission"
        elif drop_pct >= 8:
            action = "REMOVE unless business-critical"
        elif drop_pct >= 5:
            action = "REVIEW -- high cost, justify or remove"
        else:
            action = "KEEP"

        field_results.append({
            "field": label,
            "type": ftype,
            "required": required,
            "category": category,
            "estimated_drop_pct": drop_pct,
            "enrichable": enrichable,
            "monthly_leads_lost": round(leads_lost, 1),
            "monthly_dollar_impact": round(dollar_impact, 2),
            "action": action,
        })

    # Calculate optimized scenario (remove enrichable + high friction optional)
    removable_drop = sum(f["estimated_drop_pct"] for f in field_results
                         if f["action"].startswith("REMOVE"))
    optimized_rate = min(95, current_rate + removable_drop * 0.7)  # 70% recovery factor
    optimized_leads = monthly_visitors * (optimized_rate / 100.0)
    optimized_value = optimized_leads * value_per_lead

    return {
        "summary": {
            "total_fields": len(fields),
            "required_fields": sum(1 for f in field_results if f["required"]),
            "enrichable_fields": sum(1 for f in field_results if f["enrichable"]),
            "estimated_cumulative_drop_pct": min(80, cumulative_drop),
        },
        "current_performance": {
            "monthly_visitors": monthly_visitors,
            "current_rate_pct": current_rate,
            "current_monthly_leads": round(current_leads, 1),
            "current_monthly_value": round(current_monthly_value, 2),
        },
        "optimized_projection": {
            "removable_drop_pct": removable_drop,
            "projected_rate_pct": round(optimized_rate, 1),
            "projected_monthly_leads": round(optimized_leads, 1),
            "projected_monthly_value": round(optimized_value, 2),
            "monthly_value_gain": round(optimized_value - current_monthly_value, 2),
            "annual_value_gain": round((optimized_value - current_monthly_value) * 12, 2),
        },
        "field_analysis": field_results,
        "recommendations": _generate_recommendations(field_results),
    }


def _generate_recommendations(fields: list) -> list:
    """Generate recommendations."""
    recs = []
    removable = [f for f in fields if f["action"].startswith("REMOVE")]
    if removable:
        names = ", ".join(f["field"] for f in removable[:3])
        total_drop = sum(f["estimated_drop_pct"] for f in removable)
        recs.append({
            "priority": "HIGH",
            "recommendation": f"Remove {len(removable)} field(s): {names}. Estimated {total_drop}% drop reduction.",
        })

    high_cost = [f for f in fields if f["estimated_drop_pct"] >= 8 and not f["action"].startswith("REMOVE")]
    if high_cost:
        for f in high_cost:
            recs.append({
                "priority": "MEDIUM",
                "recommendation": f"'{f['field']}' has {f['estimated_drop_pct']}% drop cost. Keep only if directly used within 24 hours of submission.",
            })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 70)
    lines.append("FIELD COST ANALYZER")
    lines.append("=" * 70)

    s = result["summary"]
    lines.append(f"\nTotal Fields: {s['total_fields']} ({s['required_fields']} required, {s['enrichable_fields']} enrichable)")
    lines.append(f"Cumulative Abandonment Estimate: {s['estimated_cumulative_drop_pct']}%")

    cp = result["current_performance"]
    lines.append(f"\n--- Current Performance ---")
    lines.append(f"Monthly Visitors: {cp['monthly_visitors']:,}")
    lines.append(f"Current Rate: {cp['current_rate_pct']}%")
    lines.append(f"Monthly Leads: {cp['current_monthly_leads']:,.0f}")
    lines.append(f"Monthly Value: ${cp['current_monthly_value']:,.2f}")

    op = result["optimized_projection"]
    lines.append(f"\n--- After Removing Low-Value Fields ---")
    lines.append(f"Projected Rate: {op['projected_rate_pct']}%")
    lines.append(f"Projected Leads: {op['projected_monthly_leads']:,.0f}")
    lines.append(f"Monthly Value Gain: ${op['monthly_value_gain']:,.2f}")
    lines.append(f"Annual Value Gain: ${op['annual_value_gain']:,.2f}")

    lines.append(f"\n--- Field-by-Field Analysis ---")
    lines.append(f"{'Field':<18} {'Type':<12} {'Drop%':>6} {'$/mo Lost':>10} {'Action'}")
    for f in result["field_analysis"]:
        lines.append(
            f"{f['field']:<18} {f['type']:<12} {f['estimated_drop_pct']:>5d}% "
            f"${f['monthly_dollar_impact']:>8,.0f} {f['action']}"
        )

    if result["recommendations"]:
        lines.append(f"\n--- Recommendations ---")
        for r in result["recommendations"]:
            lines.append(f"[{r['priority']}] {r['recommendation']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Calculate abandonment cost of each form field."
    )
    parser.add_argument("input_file", help="JSON file with form fields")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--monthly-visitors", type=int, default=1000,
                        help="Monthly form visitors (default: 1000)")
    parser.add_argument("--current-rate", type=float, default=25,
                        help="Current completion rate %% (default: 25)")
    parser.add_argument("--value-per-lead", type=float, default=50,
                        help="Dollar value per lead (default: 50)")

    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 in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_fields(data, args.monthly_visitors, args.current_rate,
                            args.value_per_lead)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Form Scorer

Score a form against CRO best practices across field count, field types,
CTA quality, mobile readiness, and trust signals.

Usage:
    python form_scorer.py form_config.json
    python form_scorer.py form_config.json --json
"""

import argparse
import json
import sys


FIELD_TYPE_PENALTIES = {
    "email": 0,
    "first_name": 2,
    "last_name": 3,
    "phone": 8,
    "company": 4,
    "company_size": 4,
    "job_title": 4,
    "industry": 3,
    "message": 6,
    "budget": 10,
    "custom": 4,
}

ENRICHABLE_FIELDS = ["company", "company_size", "industry", "job_title"]


def score_form(data: dict) -> dict:
    """Score form against CRO best practices."""
    form = data.get("form", {})
    fields = form.get("fields", [])
    cta = form.get("cta", {})
    form_type = form.get("type", "lead_capture")
    has_mobile_optimization = form.get("mobile_optimized", False)
    trust_signals = form.get("trust_signals", [])
    is_multi_step = form.get("multi_step", False)
    has_validation = form.get("inline_validation", False)

    # --- Field Analysis ---
    field_count = len(fields)
    total_abandonment_cost = 0
    field_analysis = []
    enrichable_count = 0

    for f in fields:
        ftype = f.get("type", "custom")
        required = f.get("required", True)
        penalty = FIELD_TYPE_PENALTIES.get(ftype, 4)
        is_enrichable = ftype in ENRICHABLE_FIELDS

        if is_enrichable:
            enrichable_count += 1

        field_analysis.append({
            "field": f.get("label", ftype),
            "type": ftype,
            "required": required,
            "estimated_drop_pct": penalty,
            "enrichable": is_enrichable,
            "recommendation": "Remove (enrichable post-submission)" if is_enrichable and required else
                              "Keep" if penalty <= 3 else
                              "Consider removing" if penalty >= 6 else "Review necessity",
        })
        if required:
            total_abandonment_cost += penalty

    # --- Scoring Dimensions ---
    scores = {}

    # Field count score (max 25)
    if field_count <= 3:
        scores["field_count"] = 25
    elif field_count <= 5:
        scores["field_count"] = 20
    elif field_count <= 7:
        scores["field_count"] = 12
    else:
        scores["field_count"] = max(0, 25 - (field_count - 3) * 3)

    # CTA quality (max 20)
    cta_score = 0
    cta_text = cta.get("text", "Submit")
    cta_checks = []

    if cta_text.lower() != "submit":
        cta_score += 5
        cta_checks.append({"check": "Not generic 'Submit'", "passed": True})
    else:
        cta_checks.append({"check": "Not generic 'Submit'", "passed": False})

    if any(w in cta_text.lower() for w in ["my", "your", "free", "get", "start", "download"]):
        cta_score += 5
        cta_checks.append({"check": "Uses value-oriented language", "passed": True})
    else:
        cta_checks.append({"check": "Uses value-oriented language", "passed": False})

    if len(cta_text.split()) <= 5:
        cta_score += 5
        cta_checks.append({"check": "Under 5 words", "passed": True})
    else:
        cta_checks.append({"check": "Under 5 words", "passed": False})

    if cta.get("high_contrast", False):
        cta_score += 5
        cta_checks.append({"check": "High contrast button", "passed": True})
    else:
        cta_checks.append({"check": "High contrast button", "passed": False})

    scores["cta_quality"] = cta_score

    # Mobile readiness (max 20)
    mobile_score = 0
    mobile_checks = []

    if has_mobile_optimization:
        mobile_score += 8
        mobile_checks.append({"check": "Mobile-optimized layout", "passed": True})
    else:
        mobile_checks.append({"check": "Mobile-optimized layout", "passed": False})

    if form.get("single_column", True):
        mobile_score += 4
        mobile_checks.append({"check": "Single-column layout", "passed": True})
    else:
        mobile_checks.append({"check": "Single-column layout", "passed": False})

    if form.get("keyboard_types", False):
        mobile_score += 4
        mobile_checks.append({"check": "Correct keyboard types (email, tel)", "passed": True})
    else:
        mobile_checks.append({"check": "Correct keyboard types (email, tel)", "passed": False})

    if form.get("touch_targets_44px", False):
        mobile_score += 4
        mobile_checks.append({"check": "44px+ touch targets", "passed": True})
    else:
        mobile_checks.append({"check": "44px+ touch targets", "passed": False})

    scores["mobile_readiness"] = mobile_score

    # Trust signals (max 15)
    trust_score = min(15, len(trust_signals) * 5)
    scores["trust_signals"] = trust_score

    # Validation UX (max 10)
    validation_score = 0
    if has_validation:
        validation_score += 5
    if form.get("error_messages_inline", False):
        validation_score += 5
    scores["validation_ux"] = validation_score

    # Multi-step bonus (max 10)
    if is_multi_step and field_count > 5:
        scores["multi_step"] = 10
    elif not is_multi_step and field_count <= 5:
        scores["multi_step"] = 10
    elif is_multi_step and field_count <= 5:
        scores["multi_step"] = 5  # Unnecessary multi-step
    else:
        scores["multi_step"] = 0  # Should be multi-step but isn't

    total_score = sum(scores.values())
    max_score = 100

    if total_score >= 80:
        grade = "A"
    elif total_score >= 65:
        grade = "B"
    elif total_score >= 50:
        grade = "C"
    elif total_score >= 35:
        grade = "D"
    else:
        grade = "F"

    return {
        "form_type": form_type,
        "total_score": total_score,
        "max_score": max_score,
        "grade": grade,
        "scores": scores,
        "field_analysis": field_analysis,
        "field_summary": {
            "total_fields": field_count,
            "enrichable_fields": enrichable_count,
            "estimated_total_abandonment_pct": min(80, total_abandonment_cost),
        },
        "cta_checks": cta_checks,
        "mobile_checks": mobile_checks,
        "trust_signals_present": trust_signals,
        "recommendations": _generate_recommendations(scores, field_analysis, field_count, is_multi_step),
    }


def _generate_recommendations(scores: dict, fields: list, count: int, multi_step: bool) -> list:
    """Generate prioritized recommendations."""
    recs = []
    if scores["field_count"] < 15:
        removable = [f for f in fields if f["enrichable"] and f["required"]]
        if removable:
            names = ", ".join(f["field"] for f in removable[:3])
            recs.append({"priority": "HIGH", "area": "Field count",
                         "recommendation": f"Remove enrichable fields: {names}. These can be populated post-submission."})
    if scores["cta_quality"] < 15:
        recs.append({"priority": "HIGH", "area": "CTA",
                     "recommendation": "Replace generic CTA with value-specific copy (e.g., 'Get My Report' instead of 'Submit')."})
    if scores["mobile_readiness"] < 12:
        recs.append({"priority": "HIGH", "area": "Mobile",
                     "recommendation": "Implement mobile optimization: single column, 44px touch targets, correct keyboard types."})
    if scores["trust_signals"] < 10:
        recs.append({"priority": "MEDIUM", "area": "Trust",
                     "recommendation": "Add trust signals near the form: privacy assurance, security badges, or testimonial."})
    if count > 5 and not multi_step:
        recs.append({"priority": "MEDIUM", "area": "Structure",
                     "recommendation": "Convert to multi-step form. Capture email in step 1, qualifying info in step 2."})
    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"FORM CRO SCORE: {result['grade']} ({result['total_score']}/{result['max_score']})")
    lines.append("=" * 60)

    lines.append(f"\nForm Type: {result['form_type']}")
    lines.append(f"Fields: {result['field_summary']['total_fields']} ({result['field_summary']['enrichable_fields']} enrichable)")
    lines.append(f"Est. Abandonment: {result['field_summary']['estimated_total_abandonment_pct']}%")

    lines.append(f"\n--- Dimension Scores ---")
    for dim, score in result["scores"].items():
        lines.append(f"  {dim:<20} {score:>3}")

    lines.append(f"\n--- Field Analysis ---")
    lines.append(f"  {'Field':<20} {'Type':<15} {'Drop%':>6} {'Enrichable':>10} {'Action'}")
    for f in result["field_analysis"]:
        lines.append(f"  {f['field']:<20} {f['type']:<15} {f['estimated_drop_pct']:>5d}% {'Yes' if f['enrichable'] else 'No':>10} {f['recommendation']}")

    lines.append(f"\n--- CTA Checks ---")
    for c in result["cta_checks"]:
        status = "[PASS]" if c["passed"] else "[FAIL]"
        lines.append(f"  {status} {c['check']}")

    lines.append(f"\n--- Recommendations ---")
    for r in result["recommendations"]:
        lines.append(f"[{r['priority']}] {r['area']}: {r['recommendation']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Score a form against CRO best practices."
    )
    parser.add_argument("input_file", help="JSON file with form configuration")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    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 in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    result = score_form(data)

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


if __name__ == "__main__":
    main()