Email Template Builder

#!/usr/bin/env python3
"""
Email Render Size Analyzer

Analyzes email template file size, estimates render weight,
and checks against Gmail's 102KB clip threshold.

Usage:
    python render_size_analyzer.py template.html
    python render_size_analyzer.py template.html --json
    python render_size_analyzer.py --dir templates/
"""

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

GMAIL_CLIP_THRESHOLD_KB = 102
WARNING_THRESHOLD_KB = 80
OPTIMAL_SIZE_KB = 50


def analyze_file(filepath: str) -> dict:
    path = Path(filepath)
    html = path.read_text()
    raw_bytes = len(html.encode("utf-8"))
    raw_kb = raw_bytes / 1024

    # Count elements
    tags = re.findall(r"<(\w+)", html)
    tag_counts = {}
    for t in tags:
        t_lower = t.lower()
        tag_counts[t_lower] = tag_counts.get(t_lower, 0) + 1

    # Inline style weight
    inline_styles = re.findall(r'style\s*=\s*"([^"]*)"', html)
    style_bytes = sum(len(s.encode()) for s in inline_styles)
    style_kb = style_bytes / 1024

    # Style block weight
    style_blocks = re.findall(r"<style[^>]*>(.*?)</style>", html, re.DOTALL | re.IGNORECASE)
    block_bytes = sum(len(s.encode()) for s in style_blocks)
    block_kb = block_bytes / 1024

    # Image references
    img_srcs = re.findall(r'<img[^>]+src\s*=\s*"([^"]*)"', html, re.IGNORECASE)
    base64_images = [s for s in img_srcs if s.startswith("data:")]
    base64_bytes = sum(len(s.encode()) for s in base64_images)

    # Comments
    comments = re.findall(r"<!--.*?-->", html, re.DOTALL)
    comment_bytes = sum(len(c.encode()) for c in comments)

    # Whitespace
    stripped = re.sub(r"\s+", " ", html)
    minified_bytes = len(stripped.encode())
    whitespace_bytes = raw_bytes - minified_bytes

    result = {
        "file": str(path.name),
        "raw_size_kb": round(raw_kb, 2),
        "gmail_status": "CLIPPED" if raw_kb > GMAIL_CLIP_THRESHOLD_KB else "WARNING" if raw_kb > WARNING_THRESHOLD_KB else "OK",
        "headroom_kb": round(GMAIL_CLIP_THRESHOLD_KB - raw_kb, 2),
        "breakdown": {
            "inline_styles_kb": round(style_kb, 2),
            "style_blocks_kb": round(block_kb, 2),
            "base64_images_kb": round(base64_bytes / 1024, 2),
            "comments_kb": round(comment_bytes / 1024, 2),
            "whitespace_kb": round(whitespace_bytes / 1024, 2),
            "content_kb": round(minified_bytes / 1024, 2),
        },
        "element_counts": dict(sorted(tag_counts.items(), key=lambda x: -x[1])[:10]),
        "total_elements": len(tags),
        "image_count": len(img_srcs),
        "base64_image_count": len(base64_images),
        "recommendations": [],
    }

    # Recommendations
    if raw_kb > GMAIL_CLIP_THRESHOLD_KB:
        result["recommendations"].append(f"CRITICAL: Email is {raw_kb:.0f}KB -- Gmail will clip at 102KB. Reduce by {raw_kb - GMAIL_CLIP_THRESHOLD_KB:.0f}KB.")

    if base64_bytes > 0:
        result["recommendations"].append(f"Replace base64 images ({base64_bytes/1024:.1f}KB) with hosted URLs to reduce size.")

    if comment_bytes > 500:
        result["recommendations"].append(f"Remove HTML comments to save {comment_bytes/1024:.1f}KB.")

    if whitespace_bytes > raw_bytes * 0.15:
        result["recommendations"].append(f"Minify HTML to save ~{whitespace_bytes/1024:.1f}KB of whitespace.")

    if style_kb > 10:
        result["recommendations"].append("Large inline style payload. Consider consolidating repeated styles.")

    if len(tags) > 500:
        result["recommendations"].append(f"High element count ({len(tags)}). Simplify template structure.")

    if raw_kb <= OPTIMAL_SIZE_KB:
        result["recommendations"].append("Template size is optimal for fast rendering across all clients.")

    return result


def format_human(results: list) -> str:
    lines = ["\n" + "=" * 55, "  EMAIL RENDER SIZE ANALYZER", "=" * 55]

    for r in results:
        status_icon = {"OK": "+", "WARNING": "!", "CLIPPED": "X"}
        lines.append(f"\n  File: {r['file']}")
        lines.append(f"  Size: {r['raw_size_kb']}KB [{status_icon.get(r['gmail_status'], '?')}] {r['gmail_status']}")
        lines.append(f"  Gmail Headroom: {r['headroom_kb']}KB remaining")
        lines.append(f"  Elements: {r['total_elements']} | Images: {r['image_count']}")

        b = r["breakdown"]
        lines.append(f"\n  Size Breakdown:")
        lines.append(f"    Content:       {b['content_kb']}KB")
        lines.append(f"    Inline Styles: {b['inline_styles_kb']}KB")
        lines.append(f"    Style Blocks:  {b['style_blocks_kb']}KB")
        lines.append(f"    Whitespace:    {b['whitespace_kb']}KB")
        lines.append(f"    Base64 Images: {b['base64_images_kb']}KB")
        lines.append(f"    Comments:      {b['comments_kb']}KB")

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

        lines.append("-" * 55)

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Analyze email template render size and Gmail clip risk.")
    parser.add_argument("file", nargs="?", help="HTML template file")
    parser.add_argument("--dir", help="Directory of HTML templates")
    parser.add_argument("--json", action="store_true", dest="json_output")
    args = parser.parse_args()

    files = []
    if args.dir:
        dirpath = Path(args.dir)
        files = sorted(dirpath.glob("*.html"))
        if not files:
            print(f"No .html files found in {args.dir}", file=sys.stderr)
            sys.exit(1)
    elif args.file:
        files = [Path(args.file)]
    else:
        parser.print_help()
        sys.exit(1)

    results = []
    for f in files:
        try:
            results.append(analyze_file(str(f)))
        except FileNotFoundError:
            print(f"Warning: {f} not found, skipping", file=sys.stderr)

    if args.json_output:
        print(json.dumps(results if len(results) > 1 else results[0], indent=2))
    else:
        print(format_human(results))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Email Template Spam Score Checker

Analyzes email HTML templates for spam risk factors including
content-to-image ratio, link density, HTML complexity, and
deliverability best practices per 2025-2026 standards.

Usage:
    python spam_score_checker.py template.html
    python spam_score_checker.py template.html --json
"""

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

SPAM_WORDS = [
    "free", "guarantee", "act now", "limited time", "urgent", "winner",
    "click here", "buy now", "order now", "risk-free", "no obligation",
    "100% free", "amazing deal", "cash", "earn money", "double your",
    "congratulations", "you won", "apply now", "subscribe now",
]

REQUIRED_ELEMENTS = [
    ("unsubscribe_link", re.compile(r"unsubscribe|opt.out|manage.*preferences", re.IGNORECASE)),
    ("physical_address", re.compile(r"\d+\s+\w+\s+(st|street|ave|avenue|rd|road|blvd|dr|drive|suite|ste)", re.IGNORECASE)),
    ("plain_text_fallback", re.compile(r"content-type:\s*text/plain", re.IGNORECASE)),
    ("alt_text_on_images", re.compile(r'<img[^>]+alt\s*=\s*"[^"]+', re.IGNORECASE)),
]


def analyze_template(html: str) -> dict:
    result = {
        "overall_score": 10.0,
        "checks": [],
        "deductions": [],
        "recommendations": [],
    }

    plain_text = re.sub(r"<[^>]+>", " ", html)
    plain_text = re.sub(r"\s+", " ", plain_text).strip()
    text_length = len(plain_text)

    # Image analysis
    images = re.findall(r"<img[^>]*>", html, re.IGNORECASE)
    images_with_alt = len(re.findall(r'<img[^>]+alt\s*=\s*"[^"]+', html, re.IGNORECASE))
    images_without_alt = len(images) - images_with_alt
    image_area_hints = len(re.findall(r'<img[^>]*(?:width|height)', html, re.IGNORECASE))

    # Text-to-image ratio (approximate)
    html_length = len(html)
    img_chars = sum(len(img) for img in images)
    text_ratio = text_length / max(html_length, 1) * 100

    if text_ratio >= 60:
        result["checks"].append({"name": "Text-to-Image Ratio", "status": "PASS", "detail": f"{text_ratio:.0f}% text (target: 60%+)"})
    elif text_ratio >= 40:
        result["checks"].append({"name": "Text-to-Image Ratio", "status": "WARN", "detail": f"{text_ratio:.0f}% text"})
        result["overall_score"] -= 1
        result["deductions"].append("Low text-to-image ratio (-1)")
    else:
        result["checks"].append({"name": "Text-to-Image Ratio", "status": "FAIL", "detail": f"{text_ratio:.0f}% text (too image-heavy)"})
        result["overall_score"] -= 2
        result["deductions"].append("Very low text ratio (-2)")

    # Image alt text
    if images and images_without_alt > 0:
        result["checks"].append({"name": "Image Alt Text", "status": "WARN", "detail": f"{images_without_alt} image(s) missing alt text"})
        result["overall_score"] -= 0.5
    elif images:
        result["checks"].append({"name": "Image Alt Text", "status": "PASS", "detail": "All images have alt text"})

    # Link analysis
    links = re.findall(r'href\s*=\s*"([^"]*)"', html, re.IGNORECASE)
    external_links = [l for l in links if l.startswith("http")]
    shortener_links = [l for l in external_links if any(s in l for s in ["bit.ly", "tinyurl", "t.co", "goo.gl", "ow.ly"])]

    if shortener_links:
        result["checks"].append({"name": "URL Shorteners", "status": "FAIL", "detail": f"{len(shortener_links)} shortened URLs detected"})
        result["overall_score"] -= 2
        result["deductions"].append("URL shorteners trigger spam filters (-2)")
    else:
        result["checks"].append({"name": "URL Shorteners", "status": "PASS", "detail": "No URL shorteners"})

    if len(external_links) > 10:
        result["checks"].append({"name": "Link Count", "status": "WARN", "detail": f"{len(external_links)} links (high)"})
        result["overall_score"] -= 1
    else:
        result["checks"].append({"name": "Link Count", "status": "PASS", "detail": f"{len(external_links)} links"})

    # Spam words
    lower = plain_text.lower()
    found_spam = [w for w in SPAM_WORDS if w in lower]
    if not found_spam:
        result["checks"].append({"name": "Spam Trigger Words", "status": "PASS", "detail": "None detected"})
    elif len(found_spam) <= 2:
        result["checks"].append({"name": "Spam Trigger Words", "status": "WARN", "detail": f"Found: {', '.join(found_spam)}"})
        result["overall_score"] -= 0.5
    else:
        result["checks"].append({"name": "Spam Trigger Words", "status": "FAIL", "detail": f"Found {len(found_spam)}: {', '.join(found_spam)}"})
        result["overall_score"] -= 1.5

    # Required elements
    has_unsubscribe = bool(re.search(r"unsubscribe|opt.out|manage.*preferences", html, re.IGNORECASE))
    has_address = bool(re.search(r"\d+\s+\w+\s+(st|street|ave|avenue|rd|road)", html, re.IGNORECASE))

    if has_unsubscribe:
        # Check for one-click unsubscribe (RFC 8058)
        has_one_click = bool(re.search(r"list-unsubscribe|one-click", html, re.IGNORECASE))
        detail = "One-click unsubscribe detected" if has_one_click else "Unsubscribe link found (add RFC 8058 one-click header)"
        result["checks"].append({"name": "Unsubscribe", "status": "PASS", "detail": detail})
        if not has_one_click:
            result["recommendations"].append("Add RFC 8058 List-Unsubscribe and List-Unsubscribe-Post headers for Gmail/Yahoo compliance.")
    else:
        result["checks"].append({"name": "Unsubscribe", "status": "FAIL", "detail": "Missing unsubscribe mechanism"})
        result["overall_score"] -= 2
        result["deductions"].append("Missing unsubscribe (-2) -- required by CAN-SPAM, GDPR, and Gmail/Yahoo")

    if has_address:
        result["checks"].append({"name": "Physical Address", "status": "PASS", "detail": "Physical address detected"})
    else:
        result["checks"].append({"name": "Physical Address", "status": "WARN", "detail": "No physical address (CAN-SPAM requirement)"})
        result["overall_score"] -= 0.5

    # HTML validation
    unclosed_tags = 0
    for tag in ["div", "table", "tr", "td", "span", "p", "a"]:
        opens = len(re.findall(f"<{tag}[\\s>]", html, re.IGNORECASE))
        closes = len(re.findall(f"</{tag}>", html, re.IGNORECASE))
        unclosed_tags += abs(opens - closes)

    if unclosed_tags == 0:
        result["checks"].append({"name": "HTML Structure", "status": "PASS", "detail": "Tags appear balanced"})
    elif unclosed_tags <= 3:
        result["checks"].append({"name": "HTML Structure", "status": "WARN", "detail": f"~{unclosed_tags} potentially unclosed tags"})
        result["overall_score"] -= 0.5
    else:
        result["checks"].append({"name": "HTML Structure", "status": "FAIL", "detail": f"~{unclosed_tags} unclosed tags"})
        result["overall_score"] -= 1

    # Width check
    wide_elements = re.findall(r'width\s*[:=]\s*"?(\d+)', html)
    over_600 = [w for w in wide_elements if int(w) > 600]
    if over_600:
        result["checks"].append({"name": "Max Width", "status": "WARN", "detail": f"Elements wider than 600px detected"})
        result["overall_score"] -= 0.5
        result["recommendations"].append("Keep max container width at 600px for email client compatibility.")

    # Dark mode support
    has_dark_mode = bool(re.search(r"prefers-color-scheme:\s*dark", html, re.IGNORECASE))
    if has_dark_mode:
        result["checks"].append({"name": "Dark Mode", "status": "PASS", "detail": "Dark mode CSS detected"})
    else:
        result["checks"].append({"name": "Dark Mode", "status": "INFO", "detail": "No dark mode support (affects 30%+ of users)"})
        result["recommendations"].append("Add prefers-color-scheme: dark media queries for dark mode support.")

    # Subject line in meta
    has_preview = bool(re.search(r"preview|preheader", html, re.IGNORECASE))
    if has_preview:
        result["checks"].append({"name": "Preview Text", "status": "PASS", "detail": "Preview/preheader text detected"})
    else:
        result["recommendations"].append("Add preview text (80-120 chars) that complements the subject line.")

    result["overall_score"] = round(max(0, min(10, result["overall_score"])), 1)
    result["grade"] = "A" if result["overall_score"] >= 9 else "B" if result["overall_score"] >= 7 else "C" if result["overall_score"] >= 5 else "F"

    result["stats"] = {
        "html_size_bytes": len(html.encode()),
        "text_length": text_length,
        "image_count": len(images),
        "link_count": len(external_links),
        "text_ratio_percent": round(text_ratio, 1),
    }

    return result


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 55, "  EMAIL TEMPLATE SPAM SCORE CHECKER", "=" * 55]
    lines.append(f"\n  Score: {result['overall_score']}/10 (Grade: {result['grade']})")
    s = result["stats"]
    lines.append(f"  Size: {s['html_size_bytes']} bytes | Images: {s['image_count']} | Links: {s['link_count']} | Text: {s['text_ratio_percent']}%")

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

    if result["deductions"]:
        lines.append(f"\n  Deductions:")
        for d in result["deductions"]:
            lines.append(f"    - {d}")

    if result["recommendations"]:
        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="Check email template for spam risk factors.")
    parser.add_argument("file", help="HTML email template 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: File not found: {args.file}", file=sys.stderr)
        sys.exit(1)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Email Template Validator

Validates email HTML templates for client compatibility, accessibility,
responsive design, and deliverability best practices.

Usage:
    python template_validator.py template.html
    python template_validator.py template.html --json
"""

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


def validate_template(html: str) -> dict:
    result = {
        "valid": True,
        "score": 100,
        "errors": [],
        "warnings": [],
        "info": [],
        "compatibility": {},
        "accessibility": {},
    }

    # --- Structure checks ---
    has_html_tag = bool(re.search(r"<html", html, re.IGNORECASE))
    has_head = bool(re.search(r"<head", html, re.IGNORECASE))
    has_body = bool(re.search(r"<body", html, re.IGNORECASE))
    has_doctype = bool(re.search(r"<!doctype", html, re.IGNORECASE))
    has_meta_viewport = bool(re.search(r'name\s*=\s*"viewport"', html, re.IGNORECASE))
    has_charset = bool(re.search(r'charset\s*=\s*"?utf-8', html, re.IGNORECASE))
    has_lang = bool(re.search(r'<html[^>]+lang\s*=', html, re.IGNORECASE))

    if not has_html_tag:
        result["errors"].append("Missing <html> tag")
        result["score"] -= 10
    if not has_head:
        result["warnings"].append("Missing <head> tag")
        result["score"] -= 5
    if not has_body:
        result["errors"].append("Missing <body> tag")
        result["score"] -= 10
    if has_meta_viewport:
        result["info"].append("Viewport meta tag present (good for mobile)")
    if has_charset:
        result["info"].append("UTF-8 charset declared")
    if has_lang:
        result["info"].append("Language attribute set on <html>")
    else:
        result["warnings"].append("Missing lang attribute on <html> tag (accessibility)")
        result["score"] -= 3

    # --- Outlook compatibility ---
    uses_flexbox = bool(re.search(r"display\s*:\s*flex", html, re.IGNORECASE))
    uses_grid = bool(re.search(r"display\s*:\s*grid", html, re.IGNORECASE))
    uses_tables = bool(re.search(r"<table", html, re.IGNORECASE))
    uses_css_vars = bool(re.search(r"var\(--", html))
    uses_calc = bool(re.search(r"calc\(", html, re.IGNORECASE))

    compat = {}
    compat["outlook_safe"] = not uses_flexbox and not uses_grid and uses_tables
    compat["uses_tables"] = uses_tables
    compat["uses_flexbox"] = uses_flexbox
    compat["uses_grid"] = uses_grid

    if uses_flexbox:
        result["warnings"].append("CSS flexbox detected -- breaks in Outlook (Windows). Use table layout.")
        result["score"] -= 8
    if uses_grid:
        result["warnings"].append("CSS grid detected -- breaks in Outlook (Windows). Use table layout.")
        result["score"] -= 8
    if uses_css_vars:
        result["warnings"].append("CSS custom properties (variables) not supported in many email clients.")
        result["score"] -= 5
    if uses_calc:
        result["warnings"].append("calc() not supported in Outlook. Use fixed values.")
        result["score"] -= 3
    if not uses_tables:
        result["warnings"].append("No <table> elements found. Table-based layout is most compatible for email.")
        result["score"] -= 5

    result["compatibility"] = compat

    # --- Inline styles check ---
    style_blocks = len(re.findall(r"<style", html, re.IGNORECASE))
    inline_styles = len(re.findall(r'style\s*=\s*"', html, re.IGNORECASE))

    if style_blocks > 0 and inline_styles == 0:
        result["warnings"].append("Styles in <style> blocks only -- Gmail strips <head> styles. Use inline styles.")
        result["score"] -= 10
    elif inline_styles > 0:
        result["info"].append(f"Inline styles detected ({inline_styles} elements) -- good for email client compatibility.")

    # --- Image checks ---
    images = re.findall(r"<img[^>]*>", html, re.IGNORECASE)
    images_no_alt = [img for img in images if not re.search(r'alt\s*=\s*"[^"]+', img, re.IGNORECASE)]
    images_no_dims = [img for img in images if not (re.search(r'width', img, re.IGNORECASE) and re.search(r'height', img, re.IGNORECASE))]

    acc = {}
    acc["total_images"] = len(images)
    acc["images_missing_alt"] = len(images_no_alt)
    acc["images_missing_dimensions"] = len(images_no_dims)

    if images_no_alt:
        result["warnings"].append(f"{len(images_no_alt)} image(s) missing alt text (accessibility + deliverability)")
        result["score"] -= len(images_no_alt) * 2
    if images_no_dims:
        result["warnings"].append(f"{len(images_no_dims)} image(s) missing width/height (causes CLS)")
        result["score"] -= len(images_no_dims)

    result["accessibility"] = acc

    # --- Responsive check ---
    has_media_queries = bool(re.search(r"@media", html, re.IGNORECASE))
    has_max_width = bool(re.search(r"max-width", html, re.IGNORECASE))

    if has_media_queries:
        result["info"].append("Media queries detected (responsive design)")
    else:
        result["warnings"].append("No media queries found. Template may not be responsive on mobile.")
        result["score"] -= 5

    # --- Container width ---
    containers = re.findall(r'(?:max-)?width\s*[:=]\s*"?(\d+)(?:px)?', html)
    wide = [int(w) for w in containers if int(w) > 600]
    if wide:
        result["warnings"].append(f"Container wider than 600px detected ({max(wide)}px). Breaks on Gmail mobile.")
        result["score"] -= 5

    # --- Dark mode ---
    has_dark = bool(re.search(r"prefers-color-scheme:\s*dark", html, re.IGNORECASE))
    if has_dark:
        result["info"].append("Dark mode support detected")
    else:
        result["warnings"].append("No dark mode support. 30%+ of users use dark mode.")
        result["score"] -= 3

    # --- Size check ---
    size_kb = len(html.encode()) / 1024
    if size_kb > 102:
        result["errors"].append(f"Template is {size_kb:.0f}KB. Gmail clips emails over 102KB.")
        result["score"] -= 15
    elif size_kb > 80:
        result["warnings"].append(f"Template is {size_kb:.0f}KB. Approaching Gmail's 102KB clip threshold.")
        result["score"] -= 5
    else:
        result["info"].append(f"Template size: {size_kb:.1f}KB (under 102KB Gmail limit)")

    result["score"] = max(0, min(100, result["score"]))
    result["valid"] = result["score"] >= 50 and not result["errors"]
    result["grade"] = "A" if result["score"] >= 90 else "B" if result["score"] >= 75 else "C" if result["score"] >= 60 else "D" if result["score"] >= 40 else "F"

    return result


def format_human(result: dict) -> str:
    lines = ["\n" + "=" * 55, "  EMAIL TEMPLATE VALIDATOR", "=" * 55]
    lines.append(f"\n  Score: {result['score']}/100 (Grade: {result['grade']})")
    lines.append(f"  Valid: {'Yes' if result['valid'] else 'No'}")

    c = result["compatibility"]
    lines.append(f"\n  Compatibility:")
    lines.append(f"    Outlook Safe: {'Yes' if c.get('outlook_safe') else 'No'}")
    lines.append(f"    Uses Tables: {'Yes' if c.get('uses_tables') else 'No'}")

    if result["errors"]:
        lines.append(f"\n  Errors:")
        for e in result["errors"]:
            lines.append(f"    X {e}")

    if result["warnings"]:
        lines.append(f"\n  Warnings:")
        for w in result["warnings"]:
            lines.append(f"    ! {w}")

    if result["info"]:
        lines.append(f"\n  Info:")
        for i in result["info"]:
            lines.append(f"    + {i}")

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


def main():
    parser = argparse.ArgumentParser(description="Validate email HTML template for compatibility and deliverability.")
    parser.add_argument("file", help="HTML template 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 = validate_template(html)
    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()