Landing Page Generator

#!/usr/bin/env python3
"""
Landing Page Conversion Checklist

Runs a comprehensive conversion optimization audit on
landing page HTML against 2025-2026 best practices.

Usage:
    python conversion_checklist.py page.html
    python conversion_checklist.py page.html --json
"""

import argparse
import json
import re
import sys
from pathlib import Path

HTML_TAG = re.compile(r"<[^>]+>")


def audit_page(html: str) -> dict:
    lower = html.lower()
    plain = HTML_TAG.sub(" ", html)
    plain = re.sub(r"\s+", " ", plain).strip()

    checks = []
    score = 0
    max_score = 0

    def check(name, condition, points, fail_msg):
        nonlocal score, max_score
        max_score += points
        if condition:
            score += points
            checks.append({"name": name, "status": "PASS", "points": points})
        else:
            checks.append({"name": name, "status": "FAIL", "points": 0, "max_points": points, "fix": fail_msg})

    # Above the Fold
    check("H1 Tag Present", bool(re.search(r"<h1", lower)), 10, "Add a clear H1 headline")
    check("Single H1", len(re.findall(r"<h1", lower)) <= 1, 5, "Use only one H1 per page")
    check("CTA Button Present", bool(re.search(r"(btn|button|cta)", lower)), 10, "Add a prominent CTA button")
    check("Subheadline Present", bool(re.search(r"<(h2|p class[^>]*sub)", lower)), 5, "Add a subheadline under H1")

    # Navigation
    has_nav = bool(re.search(r"<nav|<header[^>]*>.*<a", lower, re.DOTALL))
    nav_link_count = len(re.findall(r"<nav.*?</nav>", lower, re.DOTALL))
    check("Minimal Navigation", not has_nav or nav_link_count <= 1, 8, "Remove navigation -- landing pages should have no exit paths")

    # Social Proof
    check("Customer Logos", bool(re.search(r"(logo|customer|trusted.by|used.by|brand)", lower)), 8, "Add customer logos or 'Trusted by' section")
    check("Testimonials", bool(re.search(r'(testimonial|review|".*".*[-—])', lower)), 8, "Add named testimonials with specific outcomes")
    check("Numbers/Metrics", bool(re.search(r"\d+\s*(team|compan|customer|user|client)", plain, re.IGNORECASE)), 5, "Add specific customer counts or metrics")

    # Trust & Credibility
    check("Security Badges", bool(re.search(r"(soc.2|gdpr|iso|secure|encrypted|ssl|badge)", lower)), 5, "Add security badges if relevant")
    check("Privacy Policy Link", bool(re.search(r"privacy", lower)), 3, "Link to privacy policy near forms")

    # CTA Optimization
    cta_count = len(re.findall(r"(btn|button|cta)", lower))
    check("Multiple CTAs", cta_count >= 2, 8, "Place CTAs at hero, mid-page, and bottom")
    check("Risk Reversal Near CTA", bool(re.search(r"(no credit card|cancel anytime|free trial|money.back|risk.free|guarantee)", lower)), 8, "Add risk reversal text near CTAs")

    # Objection Handling
    check("FAQ Section", bool(re.search(r"(faq|frequently|common question)", lower)), 5, "Add FAQ section to handle buying objections")
    check("How It Works", bool(re.search(r"(how it works|step \d|3 steps|getting started)", lower)), 5, "Add 'How It Works' section (3-4 steps)")

    # Mobile & Performance
    check("Viewport Meta", bool(re.search(r'name\s*=\s*"viewport"', lower)), 5, "Add viewport meta tag for mobile")
    check("Mobile-Friendly", bool(re.search(r"(responsive|mobile|@media)", lower)), 3, "Add responsive CSS/media queries")

    images = re.findall(r"<img[^>]*>", html, re.IGNORECASE)
    images_with_alt = len(re.findall(r'<img[^>]+alt\s*=\s*"[^"]+', html, re.IGNORECASE))
    check("Image Alt Text", not images or images_with_alt >= len(images) * 0.8, 3, "Add alt text to all images")

    # SEO
    check("Title Tag", bool(re.search(r"<title[^>]*>.+</title>", lower)), 3, "Add a title tag with primary keyword")
    check("Meta Description", bool(re.search(r'name\s*=\s*"description"', lower)), 3, "Add meta description with benefit + CTA")
    check("OG Image", bool(re.search(r'property\s*=\s*"og:image"', lower)), 2, "Add Open Graph image for social sharing")

    # Content Quality
    word_count = len(plain.split())
    check("Adequate Content", word_count >= 200, 3, "Page has very little content. Add more copy.")
    check("Not Too Long", word_count <= 3000, 2, "Page is extremely long. Consider trimming.")

    # Form optimization (if form exists)
    has_form = bool(re.search(r"<form", lower))
    if has_form:
        inputs = re.findall(r"<input[^>]+type\s*=\s*\"(?!hidden|submit|button)", lower)
        check("Form Fields < 5", len(inputs) <= 5, 5, f"Form has {len(inputs)} fields. Reduce to minimum required.")

    pct = round(score / max(max_score, 1) * 100)

    return {
        "score": pct,
        "points": f"{score}/{max_score}",
        "grade": "A" if pct >= 85 else "B" if pct >= 70 else "C" if pct >= 55 else "D" if pct >= 40 else "F",
        "checks": checks,
        "passed": sum(1 for c in checks if c["status"] == "PASS"),
        "failed": sum(1 for c in checks if c["status"] == "FAIL"),
        "total_checks": len(checks),
        "quick_wins": [c["fix"] for c in checks if c["status"] == "FAIL" and c.get("max_points", 0) >= 5][:5],
        "benchmarks": {
            "median_conversion_rate": "6.6% (all industries, 2025 data)",
            "top_10_pct": ">10% conversion rate",
            "page_load_target": "<3 seconds on mobile",
            "note": "Every second of load time reduces conversion by ~7%",
        },
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 60, "  LANDING PAGE CONVERSION CHECKLIST", "=" * 60]
    lines.append(f"\n  Score: {result['score']}% ({result['grade']}) | {result['passed']}/{result['total_checks']} checks passed")

    lines.append(f"\n  Checklist:")
    for c in result["checks"]:
        icon = "+" if c["status"] == "PASS" else "X"
        fix = f" -- {c.get('fix', '')}" if c["status"] == "FAIL" else ""
        lines.append(f"    [{icon}] {c['name']}{fix}")

    if result["quick_wins"]:
        lines.append(f"\n  Top Quick Wins:")
        for i, qw in enumerate(result["quick_wins"], 1):
            lines.append(f"    {i}. {qw}")

    b = result["benchmarks"]
    lines.append(f"\n  Benchmarks (2025-2026):")
    lines.append(f"    Median conversion: {b['median_conversion_rate']}")
    lines.append(f"    Top performers: {b['top_10_pct']}")
    lines.append(f"    Load target: {b['page_load_target']}")
    lines.append(f"    Note: {b['note']}")

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


def main():
    parser = argparse.ArgumentParser(description="Run conversion optimization checklist on landing page.")
    parser.add_argument("file", help="HTML file to audit")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    try:
        html = Path(args.file).read_text()
    except FileNotFoundError:
        print(f"Error: {args.file} not found", file=sys.stderr)
        sys.exit(1)

    result = audit_page(html)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Landing Page CTA Analyzer

Analyzes CTA placement, copy strength, friction level,
and conversion optimization on landing pages.

Usage:
    python cta_analyzer.py page.html
    python cta_analyzer.py page.html --json
"""

import argparse
import json
import re
import sys
from pathlib import Path

BUTTON_PATTERN = re.compile(r'<(button|a)[^>]*(?:class\s*=\s*"[^"]*(?:btn|button|cta)[^"]*"|role\s*=\s*"button")[^>]*>(.*?)</\1>', re.IGNORECASE | re.DOTALL)
LINK_CTA_PATTERN = re.compile(r'<a[^>]+href[^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)
HTML_TAG = re.compile(r"<[^>]+>")

STRONG_VERBS = {"start", "get", "create", "build", "try", "claim", "unlock", "discover", "join", "book", "download", "access"}
WEAK_VERBS = {"submit", "click", "send", "go", "enter", "continue"}
FRICTION_REDUCERS = ["no credit card", "free", "cancel anytime", "no commitment", "money-back", "risk-free", "2 minutes", "instant"]


def extract_ctas(html: str) -> list:
    ctas = []

    # Find buttons
    for match in BUTTON_PATTERN.finditer(html):
        text = HTML_TAG.sub("", match.group(2)).strip()
        if text and len(text) < 60:
            pos = match.start()
            ctas.append({"text": text, "position_char": pos, "type": "button"})

    # Find links that look like CTAs
    for match in LINK_CTA_PATTERN.finditer(html):
        text = HTML_TAG.sub("", match.group(1)).strip()
        tag = match.group(0).lower()
        if text and len(text) < 60 and any(kw in tag for kw in ["btn", "button", "cta", "trial", "demo", "signup", "start"]):
            pos = match.start()
            ctas.append({"text": text, "position_char": pos, "type": "link"})

    return ctas


def analyze_cta(cta_text: str) -> dict:
    lower = cta_text.lower()
    words = lower.split()
    first_word = words[0] if words else ""

    strength = "moderate"
    if first_word in STRONG_VERBS:
        strength = "strong"
    elif first_word in WEAK_VERBS:
        strength = "weak"

    has_ownership = any(w in words for w in ["my", "your"])
    has_benefit = len(words) > 2

    score = 50
    if strength == "strong":
        score += 25
    elif strength == "weak":
        score -= 15
    if has_ownership:
        score += 10
    if has_benefit:
        score += 15

    return {
        "text": cta_text,
        "strength": strength,
        "has_ownership_language": has_ownership,
        "describes_what_you_get": has_benefit,
        "word_count": len(words),
        "score": min(100, max(0, score)),
    }


def analyze_page(html: str) -> dict:
    html_length = len(html)
    ctas = extract_ctas(html)

    # Check for friction reducers near CTAs
    lower_html = html.lower()
    friction_found = [f for f in FRICTION_REDUCERS if f in lower_html]

    # Estimate CTA positions (early = above fold, middle, late)
    cta_analyses = []
    for cta in ctas:
        position_pct = (cta["position_char"] / html_length * 100) if html_length > 0 else 0
        zone = "above_fold" if position_pct < 20 else "mid_page" if position_pct < 60 else "bottom"
        analysis = analyze_cta(cta["text"])
        analysis["zone"] = zone
        analysis["position_pct"] = round(position_pct, 1)
        cta_analyses.append(analysis)

    # Scoring
    issues = []
    recommendations = []
    score = 50

    # CTA count
    if len(ctas) == 0:
        issues.append("No CTAs found on the page.")
        score -= 30
    elif len(ctas) == 1:
        issues.append("Only 1 CTA. Best practice: 2-3 CTAs throughout the page.")
        score -= 10
    elif 2 <= len(ctas) <= 4:
        score += 15
    else:
        recommendations.append(f"{len(ctas)} CTAs found -- ensure they don't compete. All should drive the same action.")

    # Above fold CTA
    above_fold = [c for c in cta_analyses if c["zone"] == "above_fold"]
    if above_fold:
        score += 15
    else:
        issues.append("No CTA above the fold. Primary CTA must be visible without scrolling.")
        score -= 15

    # CTA consistency
    cta_texts = [c["text"].lower() for c in cta_analyses]
    unique_texts = set(cta_texts)
    if len(unique_texts) > 2 and len(ctas) > 1:
        issues.append(f"{len(unique_texts)} different CTA texts. Use consistent CTAs driving one action.")
        score -= 10

    # Friction reducers
    if friction_found:
        score += 10
        recommendations.append(f"Good: Friction reducers detected: {', '.join(friction_found)}")
    else:
        recommendations.append("Add friction reducers near CTAs: 'No credit card required', 'Free for 14 days', etc.")
        score -= 5

    # CTA strength
    strong_ctas = [c for c in cta_analyses if c["strength"] == "strong"]
    weak_ctas = [c for c in cta_analyses if c["strength"] == "weak"]
    if weak_ctas:
        recommendations.append(f"Strengthen weak CTAs: {', '.join([c['text'] for c in weak_ctas][:3])}")

    score = max(0, min(100, score))

    return {
        "total_ctas": len(ctas),
        "score": score,
        "grade": "A" if score >= 85 else "B" if score >= 70 else "C" if score >= 55 else "D" if score >= 40 else "F",
        "ctas": cta_analyses,
        "friction_reducers_found": friction_found,
        "placement": {
            "above_fold": len(above_fold),
            "mid_page": len([c for c in cta_analyses if c["zone"] == "mid_page"]),
            "bottom": len([c for c in cta_analyses if c["zone"] == "bottom"]),
        },
        "issues": issues,
        "recommendations": recommendations,
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 55, "  LANDING PAGE CTA ANALYZER", "=" * 55]
    lines.append(f"\n  Score: {result['score']}/100 ({result['grade']}) | CTAs Found: {result['total_ctas']}")
    p = result["placement"]
    lines.append(f"  Placement: Above-fold: {p['above_fold']} | Mid-page: {p['mid_page']} | Bottom: {p['bottom']}")

    if result["ctas"]:
        lines.append(f"\n  CTA Analysis:")
        for c in result["ctas"]:
            lines.append(f"    \"{c['text']}\" | {c['strength']} | {c['zone']} ({c['position_pct']}%) | Score: {c['score']}")

    if result["issues"]:
        lines.append(f"\n  Issues:")
        for i in result["issues"]:
            lines.append(f"    ! {i}")

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

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


def main():
    parser = argparse.ArgumentParser(description="Analyze CTA placement and quality on landing pages.")
    parser.add_argument("file", help="HTML file")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    try:
        html = Path(args.file).read_text()
    except FileNotFoundError:
        print(f"Error: {args.file} not found", file=sys.stderr)
        sys.exit(1)

    result = analyze_page(html)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Landing Page Speed Estimator

Estimates page load performance from HTML source, checking
against Core Web Vitals targets and conversion benchmarks.

Usage:
    python page_speed_estimator.py page.html
    python page_speed_estimator.py page.html --json
"""

import argparse
import json
import re
import sys
from pathlib import Path

CWV_TARGETS = {
    "lcp": {"good": 2.5, "needs_improvement": 4.0, "unit": "seconds"},
    "cls": {"good": 0.1, "needs_improvement": 0.25, "unit": "score"},
    "fid": {"good": 100, "needs_improvement": 300, "unit": "ms"},
    "ttfb": {"good": 600, "needs_improvement": 1200, "unit": "ms"},
}


def estimate_speed(html: str) -> dict:
    size_bytes = len(html.encode("utf-8"))
    size_kb = size_bytes / 1024

    # Count resources
    scripts = re.findall(r"<script[^>]*(?:src|>)", html, re.IGNORECASE)
    external_scripts = [s for s in scripts if 'src=' in s.lower()]
    inline_scripts = [s for s in scripts if 'src=' not in s.lower()]
    stylesheets = re.findall(r'<link[^>]+rel\s*=\s*"stylesheet"', html, re.IGNORECASE)
    images = re.findall(r"<img[^>]+>", html, re.IGNORECASE)
    videos = re.findall(r"<video[^>]+>", html, re.IGNORECASE)
    iframes = re.findall(r"<iframe[^>]+>", html, re.IGNORECASE)
    fonts = re.findall(r"font-family|@font-face|fonts\.googleapis", html, re.IGNORECASE)

    # Check for optimization patterns
    has_lazy_loading = bool(re.search(r'loading\s*=\s*"lazy"', html, re.IGNORECASE))
    has_async_scripts = bool(re.search(r'<script[^>]+async', html, re.IGNORECASE))
    has_defer_scripts = bool(re.search(r'<script[^>]+defer', html, re.IGNORECASE))
    has_preload = bool(re.search(r'rel\s*=\s*"preload"', html, re.IGNORECASE))
    has_webp_avif = bool(re.search(r'\.(webp|avif)', html, re.IGNORECASE))
    has_srcset = bool(re.search(r'srcset\s*=', html, re.IGNORECASE))
    has_viewport = bool(re.search(r'name\s*=\s*"viewport"', html, re.IGNORECASE))
    images_with_dims = len(re.findall(r'<img[^>]+width[^>]+height', html, re.IGNORECASE))

    # Estimate LCP (rough)
    lcp_estimate = 1.0  # base
    lcp_estimate += size_kb / 200  # page size impact
    lcp_estimate += len(external_scripts) * 0.15  # render blocking
    lcp_estimate += len(stylesheets) * 0.1
    lcp_estimate += len(images) * 0.08
    if not has_async_scripts and not has_defer_scripts and external_scripts:
        lcp_estimate += 0.5
    if not has_webp_avif and images:
        lcp_estimate += 0.3
    if has_preload:
        lcp_estimate -= 0.2

    # CLS risk
    cls_risk = 0.0
    images_without_dims = len(images) - images_with_dims
    cls_risk += images_without_dims * 0.03
    if iframes:
        cls_risk += len(iframes) * 0.05
    if not has_viewport:
        cls_risk += 0.1

    # Build report
    checks = []

    # Page weight
    if size_kb < 500:
        checks.append({"name": "Page Weight", "status": "PASS", "detail": f"{size_kb:.0f}KB (target: <1MB)"})
    elif size_kb < 1024:
        checks.append({"name": "Page Weight", "status": "WARN", "detail": f"{size_kb:.0f}KB"})
    else:
        checks.append({"name": "Page Weight", "status": "FAIL", "detail": f"{size_kb:.0f}KB (>1MB)"})

    # Scripts
    if len(external_scripts) <= 3:
        checks.append({"name": "External Scripts", "status": "PASS", "detail": f"{len(external_scripts)} scripts"})
    else:
        checks.append({"name": "External Scripts", "status": "WARN", "detail": f"{len(external_scripts)} scripts -- reduce render-blocking JS"})

    if external_scripts and (has_async_scripts or has_defer_scripts):
        checks.append({"name": "Script Loading", "status": "PASS", "detail": "async/defer detected"})
    elif external_scripts:
        checks.append({"name": "Script Loading", "status": "WARN", "detail": "No async/defer on scripts"})

    # Images
    if images and has_lazy_loading:
        checks.append({"name": "Lazy Loading", "status": "PASS", "detail": "Lazy loading detected"})
    elif images:
        checks.append({"name": "Lazy Loading", "status": "WARN", "detail": "No lazy loading on images"})

    if images and has_webp_avif:
        checks.append({"name": "Modern Image Formats", "status": "PASS", "detail": "WebP/AVIF detected"})
    elif images:
        checks.append({"name": "Modern Image Formats", "status": "WARN", "detail": "Use WebP/AVIF for 25-50% size reduction"})

    if images_without_dims > 0:
        checks.append({"name": "Image Dimensions", "status": "WARN", "detail": f"{images_without_dims} images missing width/height (causes CLS)"})

    # CWV estimates
    lcp_status = "PASS" if lcp_estimate <= CWV_TARGETS["lcp"]["good"] else "WARN" if lcp_estimate <= CWV_TARGETS["lcp"]["needs_improvement"] else "FAIL"
    cls_status = "PASS" if cls_risk <= CWV_TARGETS["cls"]["good"] else "WARN" if cls_risk <= CWV_TARGETS["cls"]["needs_improvement"] else "FAIL"

    checks.append({"name": "Est. LCP", "status": lcp_status, "detail": f"~{lcp_estimate:.1f}s (target: <2.5s)"})
    checks.append({"name": "Est. CLS Risk", "status": cls_status, "detail": f"~{cls_risk:.2f} (target: <0.1)"})

    # Conversion impact
    conversion_impact = []
    if lcp_estimate > 3:
        lost_pct = round((lcp_estimate - 1) * 7)
        conversion_impact.append(f"~{lost_pct}% potential conversion loss from slow load time")
    if not has_viewport:
        conversion_impact.append("Missing viewport meta -- mobile users will have poor experience")

    recs = []
    if not has_async_scripts and external_scripts:
        recs.append("Add async or defer to non-critical scripts.")
    if not has_lazy_loading and images:
        recs.append("Add loading='lazy' to below-fold images.")
    if not has_webp_avif and images:
        recs.append("Convert images to WebP/AVIF format (25-50% smaller).")
    if images_without_dims > 0:
        recs.append("Add explicit width and height to all images to prevent CLS.")
    if not has_preload:
        recs.append("Add rel='preload' for critical resources (hero image, main font).")
    if size_kb > 1024:
        recs.append("Reduce page weight below 1MB. Compress images and minify CSS/JS.")

    if not recs:
        recs.append("Page looks well-optimized. Monitor CWV in Google Search Console for real-user data.")

    # Score
    score = 100
    for c in checks:
        if c["status"] == "WARN":
            score -= 8
        elif c["status"] == "FAIL":
            score -= 15
    score = max(0, min(100, score))

    return {
        "page_size_kb": round(size_kb, 1),
        "score": score,
        "grade": "A" if score >= 85 else "B" if score >= 70 else "C" if score >= 55 else "D" if score >= 40 else "F",
        "resource_counts": {
            "external_scripts": len(external_scripts),
            "inline_scripts": len(inline_scripts),
            "stylesheets": len(stylesheets),
            "images": len(images),
            "videos": len(videos),
            "iframes": len(iframes),
            "fonts": len(fonts),
        },
        "cwv_estimates": {
            "lcp_seconds": round(lcp_estimate, 1),
            "cls_risk": round(cls_risk, 2),
        },
        "checks": checks,
        "conversion_impact": conversion_impact,
        "recommendations": recs,
    }


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 55, "  LANDING PAGE SPEED ESTIMATOR", "=" * 55]
    lines.append(f"\n  Score: {result['score']}/100 ({result['grade']}) | Size: {result['page_size_kb']}KB")
    r = result["resource_counts"]
    lines.append(f"  Scripts: {r['external_scripts']}ext/{r['inline_scripts']}inline | CSS: {r['stylesheets']} | Images: {r['images']}")

    cwv = result["cwv_estimates"]
    lines.append(f"\n  Core Web Vitals Estimates:")
    lines.append(f"    LCP: ~{cwv['lcp_seconds']}s (target: <2.5s)")
    lines.append(f"    CLS Risk: ~{cwv['cls_risk']} (target: <0.1)")

    lines.append(f"\n  Checks:")
    for c in result["checks"]:
        icon = {"PASS": "+", "WARN": "!", "FAIL": "X"}
        lines.append(f"    [{icon.get(c['status'], '?')}] {c['name']}: {c['detail']}")

    if result["conversion_impact"]:
        lines.append(f"\n  Conversion Impact:")
        for ci in result["conversion_impact"]:
            lines.append(f"    !! {ci}")

    lines.append(f"\n  Recommendations:")
    for rec in result["recommendations"]:
        lines.append(f"    > {rec}")

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


def main():
    parser = argparse.ArgumentParser(description="Estimate landing page speed and Core Web Vitals.")
    parser.add_argument("file", help="HTML file to analyze")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    try:
        html = Path(args.file).read_text()
    except FileNotFoundError:
        print(f"Error: {args.file} not found", file=sys.stderr)
        sys.exit(1)

    result = estimate_speed(html)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()