Free Tool Strategy

#!/usr/bin/env python3
"""
Launch Checklist Generator

Generate a phased launch checklist (pre-launch, launch week, post-launch)
customized to the tool type and distribution channels.

Usage:
    python launch_checklist_generator.py --tool-type calculator --channels seo,producthunt,social
    python launch_checklist_generator.py --tool-type checker --channels seo,email --json
"""

import argparse
import json
import sys


TOOL_TYPES = ["calculator", "generator", "checker", "grader", "converter", "template", "visualization"]

CHANNELS = ["seo", "producthunt", "social", "email", "reddit", "hackernews", "outreach", "newsletters"]

BASE_CHECKLIST = {
    "pre_launch": [
        {"task": "Finalize tool functionality and test all inputs/outputs", "priority": "HIGH", "days_before": 14},
        {"task": "Create SEO landing page with target keyword in H1, title tag, and meta description", "priority": "HIGH", "days_before": 10},
        {"task": "Add SoftwareApplication schema markup to landing page", "priority": "MEDIUM", "days_before": 10},
        {"task": "Add FAQ section with FAQPage schema (5-7 questions)", "priority": "MEDIUM", "days_before": 10},
        {"task": "Set up analytics tracking (form views, interactions, completions, submissions)", "priority": "HIGH", "days_before": 7},
        {"task": "Configure lead capture form (email-only, positioned after results)", "priority": "HIGH", "days_before": 7},
        {"task": "Test on mobile devices (touch targets, keyboard types, responsive layout)", "priority": "HIGH", "days_before": 5},
        {"task": "Create social media preview images (OG tags, Twitter cards)", "priority": "MEDIUM", "days_before": 5},
        {"task": "Write launch announcement copy (email, social, blog)", "priority": "MEDIUM", "days_before": 3},
    ],
    "launch_week": [
        {"task": "Publish and verify landing page is indexed", "priority": "HIGH", "day": 1},
        {"task": "Send announcement to existing email subscribers", "priority": "HIGH", "day": 1},
        {"task": "Monitor for critical bugs and fix within 24 hours", "priority": "HIGH", "day": "1-7"},
        {"task": "Respond to all user feedback and questions within 12 hours", "priority": "MEDIUM", "day": "1-7"},
    ],
    "post_launch": [
        {"task": "Review analytics: usage, completion rate, lead capture rate", "priority": "HIGH", "week": 2},
        {"task": "Fix top UX issues based on analytics and feedback", "priority": "HIGH", "week": 2},
        {"task": "Submit to relevant tool directories (Free Tools, AlternativeTo)", "priority": "MEDIUM", "week": 3},
        {"task": "Reach out to 'best [category] tools' listicle authors for inclusion", "priority": "MEDIUM", "week": 3},
        {"task": "Monitor search rankings for target keywords", "priority": "MEDIUM", "week": 4},
        {"task": "Publish blog post with use cases and tips", "priority": "MEDIUM", "week": 4},
        {"task": "Iterate on lead capture based on conversion data", "priority": "MEDIUM", "week": 6},
        {"task": "Track backlinks with GSC or Ahrefs", "priority": "LOW", "week": 8},
    ],
}

CHANNEL_TASKS = {
    "producthunt": {
        "pre_launch": [
            {"task": "Prepare Product Hunt listing (tagline, description, images, first comment)", "priority": "HIGH", "days_before": 3},
            {"task": "Line up 5+ early supporters for launch day upvotes", "priority": "MEDIUM", "days_before": 3},
        ],
        "launch_week": [
            {"task": "Submit to Product Hunt (aim for Tuesday-Thursday)", "priority": "HIGH", "day": 1},
            {"task": "Engage with every Product Hunt comment within 2 hours", "priority": "HIGH", "day": 1},
        ],
    },
    "social": {
        "launch_week": [
            {"task": "Post launch thread on Twitter/X with tool demo GIF", "priority": "HIGH", "day": 1},
            {"task": "Post professional use case on LinkedIn", "priority": "MEDIUM", "day": 1},
            {"task": "Share user success stories and results on social", "priority": "LOW", "day": 7},
        ],
    },
    "reddit": {
        "launch_week": [
            {"task": "Share in relevant subreddits (genuinely helpful, not promotional)", "priority": "MEDIUM", "day": 2},
        ],
    },
    "hackernews": {
        "launch_week": [
            {"task": "Submit 'Show HN' post (only if technically interesting)", "priority": "MEDIUM", "day": 2},
        ],
    },
    "outreach": {
        "post_launch": [
            {"task": "Email bloggers and resource page owners who link to similar tools", "priority": "MEDIUM", "week": 2},
            {"task": "Pitch to industry newsletter editors for featured mention", "priority": "MEDIUM", "week": 3},
        ],
    },
    "newsletters": {
        "post_launch": [
            {"task": "Submit to relevant newsletter directories for mention", "priority": "LOW", "week": 4},
        ],
    },
    "email": {
        "launch_week": [
            {"task": "Send dedicated launch email to subscriber list", "priority": "HIGH", "day": 1},
        ],
        "post_launch": [
            {"task": "Add tool mention to email signature and newsletter footer", "priority": "LOW", "week": 2},
        ],
    },
}

TOOL_TYPE_TASKS = {
    "checker": {
        "pre_launch": [
            {"task": "Ensure detailed report output is gated behind email capture", "priority": "HIGH", "days_before": 7},
            {"task": "Add scoring rubric explanation to landing page", "priority": "MEDIUM", "days_before": 5},
        ],
    },
    "calculator": {
        "pre_launch": [
            {"task": "Add shareable results URL or social share button", "priority": "MEDIUM", "days_before": 5},
        ],
    },
    "generator": {
        "pre_launch": [
            {"task": "Add copy-to-clipboard and download buttons for generated content", "priority": "HIGH", "days_before": 5},
            {"task": "Add social share with pre-filled text for generated results", "priority": "MEDIUM", "days_before": 5},
        ],
    },
    "grader": {
        "pre_launch": [
            {"task": "Create visual scorecard output (suitable for social sharing)", "priority": "MEDIUM", "days_before": 5},
        ],
    },
    "visualization": {
        "pre_launch": [
            {"task": "Add embed code for users to embed visualization on their sites", "priority": "HIGH", "days_before": 5},
            {"task": "Ensure visualization renders correctly at common embed sizes", "priority": "MEDIUM", "days_before": 3},
        ],
    },
    "template": {
        "pre_launch": [
            {"task": "Gate downloads behind email capture (preview visible without email)", "priority": "HIGH", "days_before": 7},
        ],
    },
}


def generate_checklist(tool_type: str, channels: list) -> dict:
    """Generate customized launch checklist."""
    checklist = {
        "pre_launch": list(BASE_CHECKLIST["pre_launch"]),
        "launch_week": list(BASE_CHECKLIST["launch_week"]),
        "post_launch": list(BASE_CHECKLIST["post_launch"]),
    }

    # Add tool-type-specific tasks
    type_tasks = TOOL_TYPE_TASKS.get(tool_type, {})
    for phase, tasks in type_tasks.items():
        checklist[phase].extend(tasks)

    # Add channel-specific tasks
    for channel in channels:
        ch_tasks = CHANNEL_TASKS.get(channel, {})
        for phase, tasks in ch_tasks.items():
            checklist[phase].extend(tasks)

    # Count tasks
    total = sum(len(tasks) for tasks in checklist.values())
    high_priority = sum(1 for phase in checklist.values() for t in phase if t["priority"] == "HIGH")

    return {
        "tool_type": tool_type,
        "channels": channels,
        "summary": {
            "total_tasks": total,
            "pre_launch_tasks": len(checklist["pre_launch"]),
            "launch_week_tasks": len(checklist["launch_week"]),
            "post_launch_tasks": len(checklist["post_launch"]),
            "high_priority_tasks": high_priority,
        },
        "checklist": checklist,
    }


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"LAUNCH CHECKLIST: {result['tool_type'].upper()} TOOL")
    lines.append("=" * 60)

    lines.append(f"\nTool Type: {result['tool_type']}")
    lines.append(f"Channels: {', '.join(result['channels'])}")
    s = result["summary"]
    lines.append(f"Total Tasks: {s['total_tasks']} ({s['high_priority_tasks']} high priority)")

    for phase_name, phase_label in [("pre_launch", "PRE-LAUNCH (1-2 weeks before)"),
                                      ("launch_week", "LAUNCH WEEK"),
                                      ("post_launch", "POST-LAUNCH (weeks 2-8)")]:
        tasks = result["checklist"][phase_name]
        lines.append(f"\n--- {phase_label} ---")
        for t in tasks:
            priority_marker = "*" if t["priority"] == "HIGH" else " "
            timing = ""
            if "days_before" in t:
                timing = f" [D-{t['days_before']}]"
            elif "day" in t:
                timing = f" [Day {t['day']}]"
            elif "week" in t:
                timing = f" [Week {t['week']}]"
            lines.append(f"  {priority_marker} [ ] {t['task']}{timing}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Generate a phased launch checklist for a free tool."
    )
    parser.add_argument("--tool-type", required=True, choices=TOOL_TYPES,
                        help="Type of free tool")
    parser.add_argument("--channels", default="seo,social,email",
                        help="Comma-separated launch channels (default: seo,social,email)")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    channels = [c.strip().lower() for c in args.channels.split(",") if c.strip()]
    invalid = [c for c in channels if c not in CHANNELS]
    if invalid:
        print(f"Warning: Unknown channels ignored: {', '.join(invalid)}", file=sys.stderr)
        channels = [c for c in channels if c in CHANNELS]

    result = generate_checklist(args.tool_type, channels)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Tool Idea Scorer

Score free tool ideas against the 6-factor evaluation framework
(search volume, competition, build effort, lead capture potential,
SEO value, viral potential) and rank candidates.

Usage:
    python tool_idea_scorer.py tool_ideas.json
    python tool_idea_scorer.py tool_ideas.json --json
"""

import argparse
import json
import sys


FACTORS = [
    {"key": "search_volume", "label": "Search Volume", "max": 5},
    {"key": "competition", "label": "Competition (lack of)", "max": 5},
    {"key": "build_effort", "label": "Build Effort (ease)", "max": 5},
    {"key": "lead_capture", "label": "Lead Capture Potential", "max": 5},
    {"key": "seo_value", "label": "SEO Value", "max": 5},
    {"key": "viral_potential", "label": "Viral Potential", "max": 5},
]

THRESHOLDS = {
    "build_immediately": 25,
    "strong_candidate": 20,
    "conditional": 15,
}


def score_ideas(data: dict) -> dict:
    """Score and rank tool ideas."""
    ideas = data.get("ideas", [])
    if not ideas:
        return {"error": "No tool ideas provided."}

    scored = []
    for idea in ideas:
        name = idea.get("name", "Unknown")
        tool_type = idea.get("type", "unknown")
        scores = idea.get("scores", {})

        factor_scores = []
        total = 0
        for factor in FACTORS:
            score = min(5, max(0, scores.get(factor["key"], 0)))
            factor_scores.append({
                "factor": factor["label"],
                "key": factor["key"],
                "score": score,
                "max": factor["max"],
            })
            total += score

        # Decision
        if total >= THRESHOLDS["build_immediately"]:
            decision = "BUILD IMMEDIATELY"
            rationale = "Strong across all factors. Prioritize development."
        elif total >= THRESHOLDS["strong_candidate"]:
            decision = "STRONG CANDIDATE"
            rationale = "Validate search volume before committing resources."
        elif total >= THRESHOLDS["conditional"]:
            decision = "CONDITIONAL"
            rationale = "Build only if resources are available and strategic fit is strong."
        else:
            decision = "DO NOT BUILD"
            rationale = "Score too low. Rethink concept or find a different angle."

        # Strengths and weaknesses
        sorted_factors = sorted(factor_scores, key=lambda x: x["score"], reverse=True)
        strengths = [f for f in sorted_factors if f["score"] >= 4]
        weaknesses = [f for f in sorted_factors if f["score"] <= 2]

        scored.append({
            "name": name,
            "type": tool_type,
            "total_score": total,
            "max_score": 30,
            "percentage": round(total / 30 * 100, 1),
            "decision": decision,
            "rationale": rationale,
            "factor_scores": factor_scores,
            "strengths": [f["factor"] for f in strengths],
            "weaknesses": [f["factor"] for f in weaknesses],
        })

    scored.sort(key=lambda x: x["total_score"], reverse=True)

    return {
        "total_ideas_evaluated": len(scored),
        "build_immediately": sum(1 for s in scored if s["decision"] == "BUILD IMMEDIATELY"),
        "strong_candidates": sum(1 for s in scored if s["decision"] == "STRONG CANDIDATE"),
        "ranked_ideas": scored,
        "recommendations": _generate_recommendations(scored),
    }


def _generate_recommendations(ideas: list) -> list:
    """Generate recommendations."""
    recs = []
    top = [i for i in ideas if i["decision"] == "BUILD IMMEDIATELY"]
    if top:
        recs.append({
            "priority": "HIGH",
            "recommendation": f"Start with '{top[0]['name']}' -- highest score ({top[0]['total_score']}/30).",
        })
    elif ideas:
        recs.append({
            "priority": "MEDIUM",
            "recommendation": f"No clear winner. Consider improving the top idea '{ideas[0]['name']}' concept to address weaknesses: {', '.join(ideas[0]['weaknesses'][:2])}.",
        })

    # Common weakness
    all_weaknesses = []
    for i in ideas:
        all_weaknesses.extend(i["weaknesses"])
    if all_weaknesses:
        from collections import Counter
        common = Counter(all_weaknesses).most_common(1)
        if common:
            recs.append({
                "priority": "MEDIUM",
                "recommendation": f"Common weakness across ideas: '{common[0][0]}'. Address this in concept refinement.",
            })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append("TOOL IDEA SCORER -- 6-Factor Evaluation")
    lines.append("=" * 60)

    lines.append(f"\nIdeas Evaluated: {result['total_ideas_evaluated']}")
    lines.append(f"Build Immediately: {result['build_immediately']}")
    lines.append(f"Strong Candidates: {result['strong_candidates']}")

    for idea in result["ranked_ideas"]:
        lines.append(f"\n--- {idea['name']} ({idea['type']}) ---")
        lines.append(f"Score: {idea['total_score']}/30 ({idea['percentage']}%)")
        lines.append(f"Decision: {idea['decision']}")
        lines.append(f"Rationale: {idea['rationale']}")

        lines.append(f"  Factors:")
        for f in idea["factor_scores"]:
            bar = "#" * f["score"] + "." * (5 - f["score"])
            lines.append(f"    {f['factor']:<25} [{bar}] {f['score']}/5")

        if idea["strengths"]:
            lines.append(f"  Strengths: {', '.join(idea['strengths'])}")
        if idea["weaknesses"]:
            lines.append(f"  Weaknesses: {', '.join(idea['weaknesses'])}")

    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="Score free tool ideas against the 6-factor evaluation framework."
    )
    parser.add_argument("input_file", help="JSON file with tool ideas and scores")
    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_ideas(data)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Tool ROI Calculator

Calculate the ROI and break-even timeline for a free tool based on
traffic, conversion, and cost assumptions.

Usage:
    python tool_roi_calculator.py --build-cost 5000 --monthly-traffic 2000 --conversion-rate 8 --lead-value 50
    python tool_roi_calculator.py --build-cost 5000 --monthly-traffic 2000 --conversion-rate 8 --lead-value 50 --json
"""

import argparse
import json
import math
import sys


def calculate_roi(build_cost: float, monthly_traffic: int,
                  conversion_rate: float, lead_value: float,
                  monthly_hosting: float) -> dict:
    """Calculate free tool ROI."""
    monthly_leads = monthly_traffic * (conversion_rate / 100.0)
    monthly_value = monthly_leads * lead_value
    monthly_net = monthly_value - monthly_hosting

    # Break-even calculation
    if monthly_net > 0:
        breakeven_months = math.ceil(build_cost / monthly_net)
    else:
        breakeven_months = -1  # Never breaks even

    # 12-month projection
    monthly_projections = []
    cumulative_cost = build_cost
    cumulative_revenue = 0

    for month in range(1, 13):
        # Traffic ramp: 30% in month 1, 60% month 2, 100% month 3+
        if month == 1:
            traffic_factor = 0.30
        elif month == 2:
            traffic_factor = 0.60
        else:
            traffic_factor = 1.0

        month_traffic = int(monthly_traffic * traffic_factor)
        month_leads = month_traffic * (conversion_rate / 100.0)
        month_value = month_leads * lead_value
        cumulative_cost += monthly_hosting
        cumulative_revenue += month_value
        net_position = cumulative_revenue - cumulative_cost

        monthly_projections.append({
            "month": month,
            "traffic": month_traffic,
            "leads": round(month_leads, 1),
            "revenue": round(month_value, 2),
            "cumulative_cost": round(cumulative_cost, 2),
            "cumulative_revenue": round(cumulative_revenue, 2),
            "net_position": round(net_position, 2),
            "profitable": net_position > 0,
        })

    # Annual summary
    annual_revenue = sum(m["revenue"] for m in monthly_projections)
    annual_cost = build_cost + (monthly_hosting * 12)
    annual_roi = ((annual_revenue - annual_cost) / annual_cost * 100) if annual_cost > 0 else 0

    # Scenario analysis
    scenarios = []
    for traffic_mult, label in [(0.5, "Conservative (50% traffic)"),
                                 (1.0, "Base case"),
                                 (1.5, "Optimistic (150% traffic)"),
                                 (2.0, "Viral (200% traffic)")]:
        sc_monthly = monthly_traffic * traffic_mult * (conversion_rate / 100.0) * lead_value
        sc_annual = sc_monthly * 12  # Simplified (no ramp)
        sc_roi = ((sc_annual - annual_cost) / annual_cost * 100) if annual_cost > 0 else 0
        sc_breakeven = math.ceil(build_cost / max(0.01, sc_monthly - monthly_hosting))
        scenarios.append({
            "scenario": label,
            "monthly_revenue": round(sc_monthly, 2),
            "annual_revenue": round(sc_annual, 2),
            "annual_roi_pct": round(sc_roi, 1),
            "breakeven_months": sc_breakeven if sc_monthly > monthly_hosting else -1,
        })

    return {
        "inputs": {
            "build_cost": build_cost,
            "monthly_traffic": monthly_traffic,
            "conversion_rate_pct": conversion_rate,
            "lead_value": lead_value,
            "monthly_hosting": monthly_hosting,
        },
        "monthly_metrics": {
            "monthly_leads": round(monthly_leads, 1),
            "monthly_revenue": round(monthly_value, 2),
            "monthly_cost": monthly_hosting,
            "monthly_net": round(monthly_net, 2),
        },
        "annual_summary": {
            "annual_revenue": round(annual_revenue, 2),
            "annual_cost": round(annual_cost, 2),
            "annual_profit": round(annual_revenue - annual_cost, 2),
            "annual_roi_pct": round(annual_roi, 1),
            "breakeven_month": breakeven_months,
        },
        "monthly_projections": monthly_projections,
        "scenarios": scenarios,
        "recommendations": _generate_recommendations(breakeven_months, annual_roi, monthly_leads),
    }


def _generate_recommendations(breakeven: int, roi: float, leads: float) -> list:
    """Generate recommendations."""
    recs = []
    if breakeven <= 0:
        recs.append({
            "priority": "CRITICAL",
            "recommendation": "Tool does not break even. Increase traffic, conversion rate, or lead value -- or reduce build cost.",
        })
    elif breakeven > 6:
        recs.append({
            "priority": "HIGH",
            "recommendation": f"Break-even at month {breakeven} exceeds 6-month target. Consider reducing scope to lower build cost.",
        })
    else:
        recs.append({
            "priority": "INFO",
            "recommendation": f"Break-even at month {breakeven} -- within target. Proceed with build.",
        })

    if leads < 10:
        recs.append({
            "priority": "MEDIUM",
            "recommendation": "Monthly lead volume is low. Consider higher-traffic tool types (calculators, checkers) or broader keyword targeting.",
        })

    recs.append({
        "priority": "MEDIUM",
        "recommendation": "Factor in backlink value (not modeled here). Quality backlinks from tool pages can significantly boost domain authority.",
    })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append("FREE TOOL ROI CALCULATOR")
    lines.append("=" * 60)

    inp = result["inputs"]
    lines.append(f"\n--- Inputs ---")
    lines.append(f"Build Cost:        ${inp['build_cost']:>10,.2f}")
    lines.append(f"Monthly Traffic:   {inp['monthly_traffic']:>10,d}")
    lines.append(f"Conversion Rate:   {inp['conversion_rate_pct']:>10.1f}%")
    lines.append(f"Lead Value:        ${inp['lead_value']:>10,.2f}")
    lines.append(f"Monthly Hosting:   ${inp['monthly_hosting']:>10,.2f}")

    mm = result["monthly_metrics"]
    lines.append(f"\n--- Monthly Metrics (at full traffic) ---")
    lines.append(f"Monthly Leads:     {mm['monthly_leads']:>10.1f}")
    lines.append(f"Monthly Revenue:   ${mm['monthly_revenue']:>10,.2f}")
    lines.append(f"Monthly Net:       ${mm['monthly_net']:>10,.2f}")

    an = result["annual_summary"]
    lines.append(f"\n--- Annual Summary ---")
    lines.append(f"Annual Revenue:    ${an['annual_revenue']:>10,.2f}")
    lines.append(f"Annual Cost:       ${an['annual_cost']:>10,.2f}")
    lines.append(f"Annual Profit:     ${an['annual_profit']:>10,.2f}")
    lines.append(f"Annual ROI:        {an['annual_roi_pct']:>10.1f}%")
    be = an['breakeven_month']
    lines.append(f"Break-Even Month:  {'Never' if be <= 0 else str(be):>10}")

    lines.append(f"\n--- 12-Month Projection ---")
    lines.append(f"{'Month':>6} {'Traffic':>8} {'Leads':>7} {'Revenue':>10} {'Net Pos':>10}")
    for m in result["monthly_projections"]:
        lines.append(
            f"{m['month']:>6d} {m['traffic']:>8,d} {m['leads']:>7.0f} "
            f"${m['revenue']:>8,.0f} ${m['net_position']:>8,.0f}"
        )

    lines.append(f"\n--- Scenarios ---")
    lines.append(f"{'Scenario':<30} {'Monthly':>10} {'Annual':>10} {'ROI':>8} {'B/E':>6}")
    for s in result["scenarios"]:
        be_str = str(s["breakeven_months"]) if s["breakeven_months"] > 0 else "Never"
        lines.append(
            f"{s['scenario']:<30} ${s['monthly_revenue']:>8,.0f} "
            f"${s['annual_revenue']:>8,.0f} {s['annual_roi_pct']:>7.0f}% {be_str:>6}"
        )

    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 ROI and break-even for a free marketing tool."
    )
    parser.add_argument("--build-cost", type=float, required=True,
                        help="Total build cost in dollars")
    parser.add_argument("--monthly-traffic", type=int, required=True,
                        help="Expected monthly sessions after 90 days")
    parser.add_argument("--conversion-rate", type=float, required=True,
                        help="Expected lead conversion rate as percentage")
    parser.add_argument("--lead-value", type=float, required=True,
                        help="Dollar value per captured lead")
    parser.add_argument("--monthly-hosting", type=float, default=50,
                        help="Monthly hosting/maintenance cost (default: 50)")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    result = calculate_roi(args.build_cost, args.monthly_traffic,
                           args.conversion_rate, args.lead_value,
                           args.monthly_hosting)

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


if __name__ == "__main__":
    main()