Launch Strategy

#!/usr/bin/env python3
"""Launch Metrics Tracker - Track and analyze product launch performance metrics.

Compares actual launch metrics against targets across pre-launch, launch day,
and post-launch phases. Generates performance reports with variance analysis.

Usage:
    python launch_metrics_tracker.py metrics.json
    python launch_metrics_tracker.py metrics.json --json
    python launch_metrics_tracker.py --demo
"""

import argparse
import json
import sys


DEFAULT_TARGETS = {
    "pre_launch": {
        "waitlist_signups": {"target": 500, "unit": "signups", "direction": "higher_better"},
        "email_list_growth_pct": {"target": 10, "unit": "%", "direction": "higher_better"},
        "social_engagement_multiple": {"target": 2.0, "unit": "x", "direction": "higher_better"},
    },
    "launch_day": {
        "landing_page_visitors": {"target": 5000, "unit": "visitors", "direction": "higher_better"},
        "signup_rate": {"target": 8, "unit": "%", "direction": "higher_better"},
        "total_signups": {"target": 400, "unit": "signups", "direction": "higher_better"},
        "social_mentions": {"target": 50, "unit": "mentions", "direction": "higher_better"},
        "product_hunt_rank": {"target": 5, "unit": "rank", "direction": "lower_better"},
    },
    "post_launch_30d": {
        "total_signups_attributed": {"target": 2000, "unit": "signups", "direction": "higher_better"},
        "activation_rate": {"target": 35, "unit": "%", "direction": "higher_better"},
        "press_mentions": {"target": 3, "unit": "mentions", "direction": "higher_better"},
        "seo_keywords_ranking": {"target": 5, "unit": "keywords", "direction": "higher_better"},
        "referral_signups_pct": {"target": 15, "unit": "%", "direction": "higher_better"},
    },
}


def analyze_metrics(data, targets=None):
    """Analyze launch metrics against targets."""
    if targets is None:
        targets = DEFAULT_TARGETS

    phases = {}

    for phase_name, phase_targets in targets.items():
        actuals = data.get(phase_name, {})
        metrics = []

        for metric_name, target_info in phase_targets.items():
            actual = actuals.get(metric_name)
            target = target_info["target"]
            direction = target_info.get("direction", "higher_better")
            unit = target_info.get("unit", "")

            if actual is not None:
                if direction == "higher_better":
                    variance = actual - target
                    variance_pct = ((actual - target) / target * 100) if target != 0 else 0
                    on_track = actual >= target
                else:
                    variance = target - actual
                    variance_pct = ((target - actual) / target * 100) if target != 0 else 0
                    on_track = actual <= target

                status = "exceeded" if (variance_pct > 10) else ("on_track" if on_track else ("at_risk" if variance_pct > -20 else "missed"))
            else:
                variance = None
                variance_pct = None
                on_track = None
                status = "no_data"

            metrics.append({
                "metric": metric_name,
                "target": target,
                "actual": actual,
                "unit": unit,
                "variance": round(variance, 1) if variance is not None else None,
                "variance_pct": round(variance_pct, 1) if variance_pct is not None else None,
                "status": status,
            })

        # Phase summary
        tracked = [m for m in metrics if m["status"] != "no_data"]
        on_track_count = len([m for m in tracked if m["status"] in ("on_track", "exceeded")])
        phase_score = (on_track_count / len(tracked) * 100) if tracked else 0

        phases[phase_name] = {
            "metrics": metrics,
            "total_metrics": len(metrics),
            "tracked": len(tracked),
            "on_track": on_track_count,
            "phase_score": round(phase_score, 1),
            "phase_status": "strong" if phase_score >= 70 else ("moderate" if phase_score >= 40 else "weak"),
        }

    # Overall launch score
    all_tracked = sum(p["tracked"] for p in phases.values())
    all_on_track = sum(p["on_track"] for p in phases.values())
    overall_score = (all_on_track / all_tracked * 100) if all_tracked else 0

    # Key insights
    insights = []
    for phase_name, phase_data in phases.items():
        exceeded = [m for m in phase_data["metrics"] if m["status"] == "exceeded"]
        missed = [m for m in phase_data["metrics"] if m["status"] == "missed"]

        for m in exceeded:
            insights.append({
                "type": "positive",
                "phase": phase_name,
                "insight": f"{m['metric'].replace('_', ' ').title()} exceeded target by {m['variance_pct']:.0f}% ({m['actual']} vs {m['target']} {m['unit']})",
            })
        for m in missed:
            insights.append({
                "type": "negative",
                "phase": phase_name,
                "insight": f"{m['metric'].replace('_', ' ').title()} missed target by {abs(m['variance_pct']):.0f}% ({m['actual']} vs {m['target']} {m['unit']})",
            })

    return {
        "overall_score": round(overall_score, 1),
        "overall_status": "successful" if overall_score >= 70 else ("moderate" if overall_score >= 40 else "underperforming"),
        "phases": phases,
        "insights": insights,
        "metrics_tracked": all_tracked,
        "metrics_on_track": all_on_track,
    }


def get_demo_data():
    return {
        "pre_launch": {
            "waitlist_signups": 720,
            "email_list_growth_pct": 12,
            "social_engagement_multiple": 2.8,
        },
        "launch_day": {
            "landing_page_visitors": 8200,
            "signup_rate": 6.5,
            "total_signups": 533,
            "social_mentions": 87,
            "product_hunt_rank": 3,
        },
        "post_launch_30d": {
            "total_signups_attributed": 2850,
            "activation_rate": 32,
            "press_mentions": 5,
            "seo_keywords_ranking": 8,
            "referral_signups_pct": 11,
        },
    }


def format_report(analysis):
    """Format human-readable metrics report."""
    lines = []
    lines.append("=" * 70)
    lines.append("LAUNCH METRICS REPORT")
    lines.append("=" * 70)
    lines.append(f"Overall Score:   {analysis['overall_score']:.0f}% ({analysis['overall_status'].upper()})")
    lines.append(f"Metrics Tracked: {analysis['metrics_on_track']}/{analysis['metrics_tracked']} on track")
    lines.append("")

    for phase_name, phase_data in analysis["phases"].items():
        label = phase_name.replace("_", " ").title()
        lines.append(f"--- {label} ({phase_data['phase_status'].upper()}, {phase_data['phase_score']:.0f}%) ---")
        lines.append(f"{'Metric':<35} {'Target':>8} {'Actual':>8} {'Var %':>8} {'Status':>10}")
        lines.append("-" * 75)

        for m in phase_data["metrics"]:
            metric_label = m["metric"].replace("_", " ").title()[:34]
            target_str = f"{m['target']}{m['unit']}"
            actual_str = f"{m['actual']}{m['unit']}" if m["actual"] is not None else "N/A"
            var_str = f"{m['variance_pct']:+.0f}%" if m["variance_pct"] is not None else "N/A"

            status_marker = {
                "exceeded": "[++]",
                "on_track": "[OK]",
                "at_risk": "[!!]",
                "missed": "[XX]",
                "no_data": "[--]",
            }[m["status"]]

            lines.append(f"{metric_label:<35} {target_str:>8} {actual_str:>8} {var_str:>8} {status_marker:>10}")
        lines.append("")

    # Insights
    if analysis["insights"]:
        lines.append("--- KEY INSIGHTS ---")
        for insight in analysis["insights"]:
            marker = "+" if insight["type"] == "positive" else "-"
            lines.append(f"  [{marker}] {insight['insight']}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Track and analyze launch performance metrics")
    parser.add_argument("input", nargs="?", help="JSON file with actual metrics")
    parser.add_argument("--targets", help="Custom targets JSON file")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    parser.add_argument("--demo", action="store_true", help="Run with demo data")
    args = parser.parse_args()

    if args.demo:
        data = get_demo_data()
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                data = json.load(f)
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    targets = None
    if args.targets:
        with open(args.targets, "r", encoding="utf-8") as f:
            targets = json.load(f)

    analysis = analyze_metrics(data, targets)

    if args.json_output:
        print(json.dumps(analysis, indent=2))
    else:
        print(format_report(analysis))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Launch Readiness Checker - Assess launch preparedness across all dimensions.

Evaluates launch assets, channel preparation, team readiness, and tracking
setup to generate a go/no-go readiness score.

Usage:
    python launch_readiness_checker.py checklist.json
    python launch_readiness_checker.py checklist.json --json
    python launch_readiness_checker.py --tier 1 --interactive
"""

import argparse
import json
import sys


TIER_1_CHECKLIST = {
    "positioning": {
        "weight": 3,
        "items": [
            "One-sentence value prop defined",
            "Primary audience segment identified",
            "Key differentiator documented",
            "Competitive positioning clear",
        ],
    },
    "assets": {
        "weight": 3,
        "items": [
            "Landing page live or ready to flip",
            "Blog post drafted and reviewed",
            "Product screenshots or demo video ready",
            "Email announcement drafted",
            "Social media posts created per platform",
            "Press release or media pitch prepared",
            "Internal FAQ created",
            "Customer FAQ created",
        ],
    },
    "channels": {
        "weight": 2,
        "items": [
            "Email sequences loaded and tested",
            "Social posts scheduled",
            "Product Hunt listing prepared",
            "Community posts drafted (HN, Reddit)",
            "Paid amplification budget allocated",
            "Partner co-marketing confirmed",
        ],
    },
    "team": {
        "weight": 2,
        "items": [
            "Team briefed on launch plan",
            "Support team briefed on new feature",
            "Talking points distributed",
            "Launch day schedule shared",
            "Escalation contacts identified",
        ],
    },
    "tracking": {
        "weight": 2,
        "items": [
            "Analytics tracking configured",
            "UTM parameters created",
            "Conversion events defined",
            "Launch metrics dashboard ready",
        ],
    },
    "operations": {
        "weight": 1,
        "items": [
            "Rollback plan documented",
            "War room channel created",
            "Post-launch follow-up plan ready",
        ],
    },
}

TIER_2_CHECKLIST = {
    "positioning": {
        "weight": 3,
        "items": [
            "Value prop defined",
            "Target audience identified",
        ],
    },
    "assets": {
        "weight": 3,
        "items": [
            "Landing page or feature page ready",
            "Blog post drafted",
            "Email announcement drafted",
            "Social media posts created",
        ],
    },
    "channels": {
        "weight": 2,
        "items": [
            "Email loaded and tested",
            "Social posts scheduled",
            "In-app notification configured",
        ],
    },
    "team": {
        "weight": 1,
        "items": [
            "Team briefed",
            "Support team aware",
        ],
    },
    "tracking": {
        "weight": 2,
        "items": [
            "Analytics tracking configured",
            "UTM parameters created",
        ],
    },
}


def assess_readiness(checklist_data, tier=1):
    """Assess launch readiness from checklist responses."""
    template = TIER_1_CHECKLIST if tier == 1 else TIER_2_CHECKLIST
    category_results = {}
    total_weighted_score = 0
    total_weight = 0

    for category, config in template.items():
        items = config["items"]
        weight = config["weight"]
        responses = checklist_data.get(category, {})

        completed = 0
        incomplete = []
        for item in items:
            status = responses.get(item, False)
            if status:
                completed += 1
            else:
                incomplete.append(item)

        completion_rate = completed / max(len(items), 1)
        weighted_score = completion_rate * weight

        category_results[category] = {
            "total_items": len(items),
            "completed": completed,
            "completion_rate": round(completion_rate * 100, 1),
            "weight": weight,
            "weighted_score": round(weighted_score, 2),
            "incomplete_items": incomplete,
            "status": "ready" if completion_rate >= 0.8 else ("at_risk" if completion_rate >= 0.5 else "not_ready"),
        }

        total_weighted_score += weighted_score
        total_weight += weight

    overall_score = (total_weighted_score / total_weight * 100) if total_weight > 0 else 0

    # Go/No-Go decision
    blocking = []
    for cat, result in category_results.items():
        if result["status"] == "not_ready" and template[cat]["weight"] >= 2:
            blocking.append(cat)

    if overall_score >= 80 and not blocking:
        decision = "GO"
        rationale = "All critical categories meet minimum readiness. Proceed with launch."
    elif overall_score >= 60 and not blocking:
        decision = "CONDITIONAL GO"
        rationale = "Core readiness met. Complete remaining items in parallel with launch."
    else:
        decision = "NO-GO"
        rationale = f"Critical gaps in: {', '.join(blocking)}. Resolve before launching."

    # Risk assessment
    risks = []
    for cat, result in category_results.items():
        if result["incomplete_items"]:
            severity = "high" if template[cat]["weight"] >= 3 else ("medium" if template[cat]["weight"] >= 2 else "low")
            for item in result["incomplete_items"]:
                risks.append({
                    "category": cat,
                    "item": item,
                    "severity": severity,
                })

    risks.sort(key=lambda r: {"high": 0, "medium": 1, "low": 2}[r["severity"]])

    return {
        "tier": tier,
        "overall_score": round(overall_score, 1),
        "decision": decision,
        "rationale": rationale,
        "categories": category_results,
        "blocking_categories": blocking,
        "risks": risks,
        "total_items": sum(r["total_items"] for r in category_results.values()),
        "total_completed": sum(r["completed"] for r in category_results.values()),
    }


def run_interactive(tier=1):
    """Run interactive readiness check."""
    template = TIER_1_CHECKLIST if tier == 1 else TIER_2_CHECKLIST
    print(f"=== LAUNCH READINESS CHECK (Tier {tier}) ===")
    print("Answer y/n for each item:\n")

    checklist_data = {}
    for category, config in template.items():
        print(f"\n--- {category.upper()} ---")
        checklist_data[category] = {}
        for item in config["items"]:
            try:
                answer = input(f"  {item}? (y/n): ").strip().lower()
                checklist_data[category][item] = answer in ("y", "yes", "1", "true")
            except EOFError:
                checklist_data[category][item] = False

    return checklist_data


def format_report(analysis):
    """Format human-readable report."""
    lines = []
    lines.append("=" * 65)
    lines.append(f"LAUNCH READINESS REPORT (Tier {analysis['tier']})")
    lines.append("=" * 65)
    lines.append(f"Overall Score:    {analysis['overall_score']:.0f}%")
    lines.append(f"Decision:         {analysis['decision']}")
    lines.append(f"Rationale:        {analysis['rationale']}")
    lines.append(f"Items:            {analysis['total_completed']}/{analysis['total_items']} complete")
    lines.append("")

    # Category breakdown
    lines.append("--- CATEGORY BREAKDOWN ---")
    for cat, data in analysis["categories"].items():
        status_marker = {"ready": "[OK]", "at_risk": "[!!]", "not_ready": "[XX]"}[data["status"]]
        bar_full = int(data["completion_rate"] / 5)
        bar = "#" * bar_full + "." * (20 - bar_full)
        lines.append(f"  {status_marker} {cat:<15} [{bar}] {data['completion_rate']:.0f}% ({data['completed']}/{data['total_items']})")
    lines.append("")

    # Incomplete items by severity
    high_risks = [r for r in analysis["risks"] if r["severity"] == "high"]
    medium_risks = [r for r in analysis["risks"] if r["severity"] == "medium"]

    if high_risks:
        lines.append("--- CRITICAL GAPS (must resolve) ---")
        for r in high_risks:
            lines.append(f"  [{r['category']}] {r['item']}")
        lines.append("")

    if medium_risks:
        lines.append("--- IMPORTANT GAPS (should resolve) ---")
        for r in medium_risks:
            lines.append(f"  [{r['category']}] {r['item']}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Assess launch readiness")
    parser.add_argument("input", nargs="?", help="JSON file with checklist responses")
    parser.add_argument("--tier", type=int, choices=[1, 2], default=1, help="Launch tier")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    parser.add_argument("--interactive", action="store_true", help="Run interactive check")
    args = parser.parse_args()

    if args.interactive:
        checklist_data = run_interactive(args.tier)
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                checklist_data = json.load(f)
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    analysis = assess_readiness(checklist_data, args.tier)

    if args.json_output:
        print(json.dumps(analysis, indent=2))
    else:
        print(format_report(analysis))

    sys.exit(0 if analysis["decision"] in ("GO", "CONDITIONAL GO") else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Launch Timeline Generator - Generate phased launch timelines with milestones.

Creates a week-by-week launch plan based on tier, launch date, and channel strategy.

Usage:
    python launch_timeline_generator.py --date 2026-04-15 --tier 1
    python launch_timeline_generator.py config.json --json
"""

import argparse
import json
import sys
from datetime import datetime, timedelta


TIER_1_TIMELINE = [
    {"week_offset": -8, "phase": "Foundation", "tasks": [
        {"task": "Define positioning and messaging", "owner": "PMM", "priority": "critical"},
        {"task": "Identify primary audience segment", "owner": "PMM", "priority": "critical"},
        {"task": "Draft competitive positioning", "owner": "PMM", "priority": "high"},
        {"task": "Begin asset creation brief", "owner": "Marketing", "priority": "high"},
    ]},
    {"week_offset": -6, "phase": "Asset Creation", "tasks": [
        {"task": "Write landing page copy", "owner": "Copywriter", "priority": "critical"},
        {"task": "Create product screenshots/demo video", "owner": "Design", "priority": "critical"},
        {"task": "Draft blog announcement post", "owner": "Content", "priority": "high"},
        {"task": "Draft email announcement", "owner": "Email", "priority": "high"},
        {"task": "Create social media content calendar", "owner": "Social", "priority": "medium"},
    ]},
    {"week_offset": -4, "phase": "Channel Preparation", "tasks": [
        {"task": "Build and test landing page", "owner": "Web", "priority": "critical"},
        {"task": "Set up tracking and UTMs", "owner": "Analytics", "priority": "critical"},
        {"task": "Prepare Product Hunt listing", "owner": "Marketing", "priority": "medium"},
        {"task": "Draft press release / media pitch", "owner": "PR", "priority": "medium"},
        {"task": "Begin audience warming on social", "owner": "Social", "priority": "medium"},
        {"task": "Set up waitlist if applicable", "owner": "Web", "priority": "medium"},
    ]},
    {"week_offset": -2, "phase": "Final Preparation", "tasks": [
        {"task": "Review all assets (final approval)", "owner": "Marketing Lead", "priority": "critical"},
        {"task": "Load email sequences and test", "owner": "Email", "priority": "critical"},
        {"task": "Schedule social posts", "owner": "Social", "priority": "high"},
        {"task": "Brief team on launch plan", "owner": "Marketing Lead", "priority": "critical"},
        {"task": "Brief support team", "owner": "Support Lead", "priority": "high"},
        {"task": "Configure paid ad campaigns", "owner": "Paid", "priority": "high"},
        {"task": "Document rollback plan", "owner": "Engineering", "priority": "medium"},
    ]},
    {"week_offset": -1, "phase": "Pre-Launch Week", "tasks": [
        {"task": "Final landing page QA", "owner": "QA", "priority": "critical"},
        {"task": "Test all tracking fires correctly", "owner": "Analytics", "priority": "critical"},
        {"task": "Confirm partner co-promotions", "owner": "Partnerships", "priority": "medium"},
        {"task": "Send pre-launch teaser to VIP list", "owner": "Email", "priority": "medium"},
        {"task": "Prepare launch day war room", "owner": "Marketing Lead", "priority": "high"},
    ]},
    {"week_offset": 0, "phase": "LAUNCH WEEK", "tasks": [
        {"task": "Launch Day: Flip page live, send emails, publish posts", "owner": "All", "priority": "critical"},
        {"task": "Monitor analytics every 2 hours", "owner": "Analytics", "priority": "critical"},
        {"task": "Respond to all comments/questions", "owner": "Social + Support", "priority": "critical"},
        {"task": "Product Hunt engagement (if applicable)", "owner": "Founders", "priority": "high"},
        {"task": "Send Day 2 follow-up content", "owner": "Content", "priority": "high"},
        {"task": "Share early results with team", "owner": "Marketing Lead", "priority": "medium"},
    ]},
    {"week_offset": 1, "phase": "Post-Launch Week 1", "tasks": [
        {"task": "Publish 'what we learned' content", "owner": "Content", "priority": "high"},
        {"task": "Collect early user testimonials", "owner": "CS", "priority": "high"},
        {"task": "Create comparison pages", "owner": "Content", "priority": "medium"},
        {"task": "Fix any reported issues", "owner": "Engineering", "priority": "critical"},
        {"task": "Share public metrics if impressive", "owner": "Social", "priority": "medium"},
    ]},
    {"week_offset": 3, "phase": "Post-Launch Month", "tasks": [
        {"task": "Publish case study or user story", "owner": "Content", "priority": "high"},
        {"task": "Submit to directories (G2, Capterra)", "owner": "Marketing", "priority": "medium"},
        {"task": "Run retargeting on non-converters", "owner": "Paid", "priority": "medium"},
        {"task": "Full launch retrospective", "owner": "Marketing Lead", "priority": "high"},
        {"task": "Document playbook for next launch", "owner": "Marketing Lead", "priority": "medium"},
    ]},
]

TIER_2_TIMELINE = [
    {"week_offset": -4, "phase": "Foundation & Assets", "tasks": [
        {"task": "Define messaging for feature", "owner": "PMM", "priority": "critical"},
        {"task": "Write feature page or update", "owner": "Copywriter", "priority": "critical"},
        {"task": "Draft blog post", "owner": "Content", "priority": "high"},
        {"task": "Create email announcement", "owner": "Email", "priority": "high"},
    ]},
    {"week_offset": -2, "phase": "Preparation", "tasks": [
        {"task": "Set up tracking", "owner": "Analytics", "priority": "critical"},
        {"task": "Schedule social posts", "owner": "Social", "priority": "high"},
        {"task": "Brief team", "owner": "Marketing Lead", "priority": "high"},
        {"task": "Load email sequences", "owner": "Email", "priority": "high"},
    ]},
    {"week_offset": 0, "phase": "LAUNCH", "tasks": [
        {"task": "Publish page, send email, post social", "owner": "All", "priority": "critical"},
        {"task": "Monitor analytics", "owner": "Analytics", "priority": "high"},
        {"task": "In-app notification active", "owner": "Product", "priority": "high"},
    ]},
    {"week_offset": 1, "phase": "Follow-Up", "tasks": [
        {"task": "Collect feedback and testimonials", "owner": "CS", "priority": "medium"},
        {"task": "Share results internally", "owner": "Marketing Lead", "priority": "medium"},
    ]},
]


def generate_timeline(launch_date, tier=1, custom_tasks=None):
    """Generate a dated timeline from launch date and tier."""
    template = TIER_1_TIMELINE if tier == 1 else TIER_2_TIMELINE

    if isinstance(launch_date, str):
        launch_date = datetime.strptime(launch_date, "%Y-%m-%d")

    phases = []
    all_tasks = []

    for phase_template in template:
        offset_days = phase_template["week_offset"] * 7
        phase_start = launch_date + timedelta(days=offset_days)

        phase = {
            "phase": phase_template["phase"],
            "start_date": phase_start.strftime("%Y-%m-%d"),
            "week_offset": phase_template["week_offset"],
            "tasks": [],
        }

        for task in phase_template["tasks"]:
            task_entry = {
                "task": task["task"],
                "owner": task["owner"],
                "priority": task["priority"],
                "due_date": phase_start.strftime("%Y-%m-%d"),
                "status": "pending",
            }
            phase["tasks"].append(task_entry)
            all_tasks.append(task_entry)

        phases.append(phase)

    # Add custom tasks
    if custom_tasks:
        for ct in custom_tasks:
            offset = ct.get("week_offset", 0)
            task_date = launch_date + timedelta(days=offset * 7)
            task_entry = {
                "task": ct.get("task", "Custom task"),
                "owner": ct.get("owner", "TBD"),
                "priority": ct.get("priority", "medium"),
                "due_date": task_date.strftime("%Y-%m-%d"),
                "status": "pending",
            }
            all_tasks.append(task_entry)

    total_duration = (phases[-1]["start_date"] if phases else launch_date.strftime("%Y-%m-%d"))
    prep_start = phases[0]["start_date"] if phases else launch_date.strftime("%Y-%m-%d")

    return {
        "tier": tier,
        "launch_date": launch_date.strftime("%Y-%m-%d"),
        "preparation_start": prep_start,
        "total_tasks": len(all_tasks),
        "critical_tasks": len([t for t in all_tasks if t["priority"] == "critical"]),
        "phases": phases,
    }


def format_report(timeline):
    """Format human-readable timeline."""
    lines = []
    lines.append("=" * 70)
    lines.append(f"LAUNCH TIMELINE (Tier {timeline['tier']})")
    lines.append("=" * 70)
    lines.append(f"Launch Date:       {timeline['launch_date']}")
    lines.append(f"Prep Starts:       {timeline['preparation_start']}")
    lines.append(f"Total Tasks:       {timeline['total_tasks']}")
    lines.append(f"Critical Tasks:    {timeline['critical_tasks']}")
    lines.append("")

    for phase in timeline["phases"]:
        is_launch = "LAUNCH" in phase["phase"].upper()
        marker = ">>>" if is_launch else "---"
        lines.append(f"{marker} {phase['phase']} (Week {phase['week_offset']:+d}, {phase['start_date']}) {marker}")

        for task in phase["tasks"]:
            priority_marker = {"critical": "!!!", "high": "!!", "medium": "!", "low": ""}[task["priority"]]
            lines.append(f"    [{task['priority'][:1].upper()}] {priority_marker} {task['task']} ({task['owner']})")
        lines.append("")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Generate phased launch timelines")
    parser.add_argument("input", nargs="?", help="JSON config file")
    parser.add_argument("--date", help="Launch date (YYYY-MM-DD)")
    parser.add_argument("--tier", type=int, choices=[1, 2], default=1, help="Launch tier")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    args = parser.parse_args()

    if args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                config = json.load(f)
            launch_date = config.get("launch_date", config.get("date"))
            tier = config.get("tier", args.tier)
            custom_tasks = config.get("custom_tasks", [])
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    elif args.date:
        launch_date = args.date
        tier = args.tier
        custom_tasks = []
    else:
        parser.print_help()
        sys.exit(1)

    timeline = generate_timeline(launch_date, tier, custom_tasks)

    if args.json_output:
        print(json.dumps(timeline, indent=2))
    else:
        print(format_report(timeline))


if __name__ == "__main__":
    main()