@da-trollefsen/claude-wrapped 1.0.0

package/claude_code_wrapped/exporters/markdown_exporter.py

@@ -0,0 +1,462 @@
+"""Markdown export for Claude Code Wrapped."""
+
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from ..stats import WrappedStats, format_tokens
+from ..pricing import format_cost
+from ..ui import CONTRIB_COLORS, determine_personality, get_fun_facts, simplify_model_name, format_year_display
+
+
+def export_to_markdown(stats: WrappedStats, year: int | None, output_path: Path) -> None:
+    """Export wrapped stats to a nicely formatted Markdown file.
+
+    Args:
+        stats: Wrapped statistics dataclass
+        year: Year being wrapped
+        output_path: Path to output Markdown file
+    """
+    personality = determine_personality(stats)
+    fun_facts = get_fun_facts(stats)
+
+    # Calculate date range
+    if year is None:
+        # All-time: use first and last message dates
+        start_date = stats.first_message_date or datetime.now()
+        end_date = stats.last_message_date or datetime.now()
+    else:
+        start_date = datetime(year, 1, 1)
+        today = datetime.now()
+        end_date = today if year == today.year else datetime(year, 12, 31)
+
+    # Build Markdown
+    markdown = _build_markdown_document(stats, year, personality, fun_facts, start_date, end_date)
+
+    # Write to file
+    output_path.write_text(markdown, encoding='utf-8')
+
+
+def _build_markdown_document(stats: WrappedStats, year: int | None, personality: dict,
+                              fun_facts: list, start_date: datetime, end_date: datetime) -> str:
+    """Build the complete Markdown document."""
+
+    sections = [
+        _build_title_section(year),
+        _build_dramatic_reveals(stats, start_date, end_date),
+        _build_dashboard(stats, year, personality),
+        _build_contribution_graph(stats.daily_stats, year),
+        _build_charts(stats),
+        _build_tools_and_projects(stats),
+        _build_mcp_section(stats),
+        _build_monthly_costs(stats),
+        _build_fun_facts_section(fun_facts),
+        _build_credits(stats, year),
+    ]
+
+    return "\n\n".join(filter(None, sections))
+
+
+def _build_title_section(year: int | None) -> str:
+    """Build the title section."""
+    year_display = format_year_display(year)
+    return f"""# 🎬 CLAUDE CODE WRAPPED
+## Your {year_display}
+
+*A year in review · Generated {datetime.now().strftime('%B %d, %Y')}*"""
+
+
+def _build_dramatic_reveals(stats: WrappedStats, start_date: datetime, end_date: datetime) -> str:
+    """Build the dramatic reveal sections."""
+    date_range = f"{start_date.strftime('%B %d')} - {end_date.strftime('%B %d, %Y')}"
+
+    sections = [
+        f"""---
+
+## 📊 Total Messages
+
+**{stats.total_messages:,}** messages
+
+*{date_range}*""",
+
+        f"""---
+
+## 📈 Your Averages
+
+### Messages
+- **{stats.avg_messages_per_day:.1f}** per day
+- **{stats.avg_messages_per_week:.1f}** per week
+- **{stats.avg_messages_per_month:.1f}** per month"""
+    ]
+
+    if stats.estimated_cost is not None:
+        sections[-1] += f"""
+
+### Cost
+- **{format_cost(stats.avg_cost_per_day)}** per day
+- **{format_cost(stats.avg_cost_per_week)}** per week
+- **{format_cost(stats.avg_cost_per_month)}** per month"""
+
+    sections.append(f"""---
+
+## 🔢 Total Tokens
+
+**{stats.total_tokens:,}** tokens ({format_tokens(stats.total_tokens)})
+
+- Input: {format_tokens(stats.total_input_tokens)}
+- Output: {format_tokens(stats.total_output_tokens)}""")
+
+    return "\n\n".join(sections)
+
+
+def _build_dashboard(stats: WrappedStats, year: int | None, personality: dict) -> str:
+    """Build the main dashboard section."""
+
+    year_display = format_year_display(year)
+    return f"""---
+
+## 📋 Your {year_display} Dashboard
+
+| Messages | Sessions | Tokens | Streak |
+|----------|----------|--------|--------|
+| {stats.total_messages:,} | {stats.total_sessions:,} | {format_tokens(stats.total_tokens)} | {stats.streak_longest} days |
+
+### {personality['emoji']} {personality['title']}
+
+*{personality['description']}*"""
+
+
+def _build_contribution_graph(daily_stats: dict, year: int | None) -> str:
+    """Build ASCII contribution graph."""
+    if not daily_stats:
+        return "### 📅 Activity Graph\n\n*No activity data*"
+
+    # Calculate date range
+    if year is None:
+        # All-time: use actual date range from daily_stats
+        dates = [datetime.strptime(d, "%Y-%m-%d") for d in daily_stats.keys()]
+        start_date = min(dates) if dates else datetime.now()
+        end_date = max(dates) if dates else datetime.now()
+    else:
+        start_date = datetime(year, 1, 1)
+        today = datetime.now()
+        end_date = today if year == today.year else datetime(year, 12, 31)
+
+    # Calculate max count for color scaling
+    max_count = max(s.message_count for s in daily_stats.values()) if daily_stats else 1
+
+    # Build weeks grid
+    weeks = []
+    current = start_date - timedelta(days=start_date.weekday())
+
+    while current <= end_date + timedelta(days=7):
+        week = []
+        for day in range(7):
+            date = current + timedelta(days=day)
+            date_str = date.strftime("%Y-%m-%d")
+
+            if date < start_date or date > end_date:
+                week.append(None)
+            elif date_str in daily_stats:
+                count = daily_stats[date_str].message_count
+                level = min(4, 1 + int((count / max_count) * 3)) if count > 0 else 0
+                week.append(level)
+            else:
+                week.append(0)
+
+        weeks.append(week)
+        current += timedelta(days=7)
+
+    # Build ASCII graph
+    graph = "```\n"
+    days_labels = ["Mon", "   ", "Wed", "   ", "Fri", "   ", "   "]
+
+    for row in range(7):
+        graph += f"{days_labels[row]} "
+        for week in weeks:
+            if week[row] is None:
+                graph += "  "
+            else:
+                graph += "■ "
+        graph += "\n"
+
+    graph += "\n     Less ■ ■ ■ ■ ■ More\n"
+    graph += "```"
+
+    # Activity count
+    active_count = len([d for d in daily_stats.values() if d.message_count > 0])
+    total_days = (end_date - start_date).days + 1
+
+    return f"""---
+
+## 📅 Activity Graph
+
+*{active_count} of {total_days} days active*
+
+{graph}"""
+
+
+def _build_charts(stats: WrappedStats) -> str:
+    """Build weekday and hourly charts."""
+
+    # Weekday chart
+    days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    max_weekday = max(stats.weekday_distribution) if stats.weekday_distribution else 1
+
+    weekday_chart = "### Weekday Activity\n\n```\n"
+    for i, (day, count) in enumerate(zip(days, stats.weekday_distribution)):
+        bar_width = int((count / max_weekday) * 30)
+        bar = "█" * bar_width
+        weekday_chart += f"{day} {bar} {count:,}\n"
+    weekday_chart += "```"
+
+    # Hourly chart
+    max_hourly = max(stats.hourly_distribution) if stats.hourly_distribution else 1
+
+    hourly_chart = "### Hourly Activity\n\n```\n"
+    for hour, count in enumerate(stats.hourly_distribution):
+        if count > 0:
+            bar_width = int((count / max_hourly) * 40)
+            bar = "█" * bar_width
+            hourly_chart += f"{hour:02d}:00 {bar} {count:,}\n"
+    hourly_chart += "```"
+
+    return f"""---
+
+## 📊 Activity Patterns
+
+{weekday_chart}
+
+{hourly_chart}"""
+
+
+def _build_tools_and_projects(stats: WrappedStats) -> str:
+    """Build tools and projects sections."""
+
+    sections = []
+
+    # Top Tools
+    if stats.top_tools:
+        max_tool = stats.top_tools[0][1]
+        tools_md = "### 🔧 Top Tools\n\n```\n"
+        for tool, count in stats.top_tools[:5]:
+            bar_width = int((count / max_tool) * 30)
+            bar = "█" * bar_width
+            tools_md += f"{tool:<20} {bar} {count:,}\n"
+        tools_md += "```"
+        sections.append(tools_md)
+
+    # Top Projects
+    if stats.top_projects:
+        max_proj = stats.top_projects[0][1]
+        projects_md = "### 📁 Top Projects\n\n```\n"
+        for proj, count in stats.top_projects[:5]:
+            bar_width = int((count / max_proj) * 30)
+            bar = "█" * bar_width
+            # Truncate long names
+            display_name = proj if len(proj) <= 20 else proj[:17] + "..."
+            projects_md += f"{display_name:<20} {bar} {count:,}\n"
+        projects_md += "```"
+        sections.append(projects_md)
+
+    if sections:
+        return "---\n\n## 🛠️  Tools & Projects\n\n" + "\n\n".join(sections)
+
+    return ""
+
+
+def _build_mcp_section(stats: WrappedStats) -> str:
+    """Build MCP servers section if any."""
+    if not stats.top_mcps:
+        return ""
+
+    max_mcp = stats.top_mcps[0][1]
+
+    mcp_md = "```\n"
+    for mcp, count in stats.top_mcps[:3]:
+        bar_width = int((count / max_mcp) * 30)
+        bar = "█" * bar_width
+        mcp_md += f"{mcp:<20} {bar} {count:,}\n"
+    mcp_md += "```"
+
+    return f"""---
+
+## 🔌 MCP Servers
+
+{mcp_md}"""
+
+
+def _build_monthly_costs(stats: WrappedStats) -> str:
+    """Build monthly cost breakdown table."""
+    if not stats.monthly_costs:
+        return ""
+
+    # Build table
+    table = "| Month | Input | Output | Cache | Cost |\n"
+    table += "|-------|-------|--------|-------|------|\n"
+
+    total_cost = 0
+    total_input = 0
+    total_output = 0
+    total_cache = 0
+
+    for month_str in sorted(stats.monthly_costs.keys()):
+        cost = stats.monthly_costs[month_str]
+        total_cost += cost
+
+        # Get tokens for this month
+        if month_str in stats.monthly_tokens:
+            tokens = stats.monthly_tokens[month_str]
+            input_tokens = tokens.get('input', 0)
+            output_tokens = tokens.get('output', 0)
+            cache_tokens = tokens.get('cache_create', 0) + tokens.get('cache_read', 0)
+
+            total_input += input_tokens
+            total_output += output_tokens
+            total_cache += cache_tokens
+
+            # Format month
+            month_date = datetime.strptime(month_str, "%Y-%m")
+            month_label = month_date.strftime("%b %Y")
+
+            table += f"| {month_label} | {format_tokens(input_tokens)} | {format_tokens(output_tokens)} | {format_tokens(cache_tokens)} | {format_cost(cost)} |\n"
+
+    table += f"| **Total** | **{format_tokens(total_input)}** | **{format_tokens(total_output)}** | **{format_tokens(total_cache)}** | **{format_cost(total_cost)}** |\n"
+
+    return f"""---
+
+## 💰 Monthly Cost Breakdown
+
+{table}"""
+
+
+def _build_fun_facts_section(fun_facts: list) -> str:
+    """Build fun facts section."""
+    if not fun_facts:
+        return ""
+
+    facts_md = "\n".join([f"- {emoji} {fact}" for emoji, fact in fun_facts])
+
+    return f"""---
+
+## 💡 Insights
+
+{facts_md}"""
+
+
+def _build_credits(stats: WrappedStats, year: int | None) -> str:
+    """Build credits section."""
+
+    # Aggregate costs by simplified model name
+    display_costs = {}
+    for model, cost in stats.cost_by_model.items():
+        display_name = simplify_model_name(model)
+        display_costs[display_name] = display_costs.get(display_name, 0) + cost
+
+    sections = []
+
+    # The Numbers
+    numbers = "### 💵 THE NUMBERS\n\n"
+    if stats.estimated_cost is not None:
+        numbers += f"**Estimated Cost:** {format_cost(stats.estimated_cost)}\n\n"
+        for model, cost in sorted(display_costs.items(), key=lambda x: -x[1]):
+            numbers += f"- {model}: {format_cost(cost)}\n"
+        numbers += "\n"
+
+    numbers += f"**Tokens:** {format_tokens(stats.total_tokens)}\n\n"
+    numbers += f"- Input: {format_tokens(stats.total_input_tokens)}\n"
+    numbers += f"- Output: {format_tokens(stats.total_output_tokens)}\n"
+    sections.append(numbers)
+
+    # Timeline
+    today = datetime.now()
+    if year is None:
+        # All-time: calculate days from first to last message
+        if stats.first_message_date and stats.last_message_date:
+            total_days = (stats.last_message_date - stats.first_message_date).days + 1
+        else:
+            total_days = stats.active_days
+    elif year == today.year:
+        total_days = (today - datetime(year, 1, 1)).days + 1
+    else:
+        total_days = 366 if year % 4 == 0 else 365
+
+    year_display = format_year_display(year)
+    # Use sentence case for "All time" in Period field
+    period_text = "All time" if year is None else year_display
+    timeline = "### 📅 TIMELINE\n\n"
+    timeline += f"- **Period:** {period_text}\n"
+    if stats.first_message_date:
+        date_str = stats.first_message_date.strftime('%B %d, %Y') if year is None else stats.first_message_date.strftime('%B %d')
+        timeline += f"- **Journey started:** {date_str}\n"
+    timeline += f"- **Active days:** {stats.active_days} of {total_days}\n"
+    if stats.most_active_hour is not None:
+        hour_label = "AM" if stats.most_active_hour < 12 else "PM"
+        hour_12 = stats.most_active_hour % 12 or 12
+        timeline += f"- **Peak hour:** {hour_12}:00 {hour_label}\n"
+    sections.append(timeline)
+
+    # Averages
+    averages = "### 📊 AVERAGES\n\n"
+    averages += "**Messages:**\n"
+    averages += f"- Per day: {stats.avg_messages_per_day:.1f}\n"
+    averages += f"- Per week: {stats.avg_messages_per_week:.1f}\n"
+    averages += f"- Per month: {stats.avg_messages_per_month:.1f}\n"
+
+    if stats.estimated_cost is not None:
+        averages += "\n**Cost:**\n"
+        averages += f"- Per day: {format_cost(stats.avg_cost_per_day)}\n"
+        averages += f"- Per week: {format_cost(stats.avg_cost_per_week)}\n"
+        averages += f"- Per month: {format_cost(stats.avg_cost_per_month)}\n"
+    sections.append(averages)
+
+    # Longest Streak (if significant)
+    if stats.streak_longest >= 3 and stats.streak_longest_start and stats.streak_longest_end:
+        streak = "### 🔥 LONGEST STREAK\n\n"
+        streak += f"- **{stats.streak_longest} days** of consistent coding\n"
+        streak += f"- **From:** {stats.streak_longest_start.strftime('%B %d, %Y')}\n"
+        streak += f"- **To:** {stats.streak_longest_end.strftime('%B %d, %Y')}\n"
+        streak += "\n*Consistency is the key to mastery.*"
+        if stats.streak_current > 0:
+            streak += f"\n\n*Current streak: {stats.streak_current} days*"
+        sections.append(streak)
+
+    # Longest Conversation
+    if stats.longest_conversation_messages > 0:
+        longest = "### 💬 LONGEST CONVERSATION\n\n"
+        longest += f"- **Messages:** {stats.longest_conversation_messages:,}\n"
+        if stats.longest_conversation_tokens > 0:
+            longest += f"- **Tokens:** {format_tokens(stats.longest_conversation_tokens)}\n"
+        if stats.longest_conversation_date:
+            longest += f"- **Date:** {stats.longest_conversation_date.strftime('%B %d, %Y')}\n"
+        longest += "\n*That's one epic coding session!*"
+        sections.append(longest)
+
+    # Starring (Models)
+    starring = "### ⭐ STARRING\n\n"
+    for model, count in stats.models_used.most_common(3):
+        starring += f"- **Claude {model}** ({count:,} messages)\n"
+    sections.append(starring)
+
+    # Projects
+    if stats.top_projects:
+        projects = "### 📁 PROJECTS\n\n"
+        for proj, count in stats.top_projects[:5]:
+            projects += f"- **{proj}** ({count:,} messages)\n"
+        sections.append(projects)
+
+    # Final card
+    if year is not None:
+        final = f"""---
+
+## 👋 See you in {year + 1}
+
+**Created by** [Daniel Tollefsen](https://github.com/da-troll) · [github.com/da-troll/claude-wrapped](https://github.com/da-troll/claude-wrapped)"""
+    else:
+        final = """---
+
+## 👋 Keep coding!
+
+**Created by** [Daniel Tollefsen](https://github.com/da-troll) · [github.com/da-troll/claude-wrapped](https://github.com/da-troll/claude-wrapped)"""
+    sections.append(final)
+
+    return "---\n\n## 🎬 CREDITS\n\n" + "\n\n".join(sections)

package/claude_code_wrapped/interactive.py

@@ -0,0 +1,166 @@
+"""Interactive mode for Claude Code Wrapped using questionary prompts."""
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import questionary
+from questionary import Style
+from rich.console import Console
+
+# Custom styling to match the wrapped aesthetic
+custom_style = Style([
+    ('qmark', 'fg:#E67E22 bold'),       # Orange question mark
+    ('question', 'bold'),                # Question text
+    ('answer', 'fg:#9B59B6 bold'),      # Purple answer
+    ('pointer', 'fg:#E67E22 bold'),     # Orange pointer
+    ('highlighted', 'fg:#E67E22 bold'), # Orange highlighted choice
+    ('selected', 'fg:#9B59B6'),         # Purple selected
+    ('separator', 'fg:#7F8C8D'),        # Gray separator
+    ('instruction', 'fg:#7F8C8D'),      # Gray instructions
+])
+
+
+def get_available_years() -> list[str]:
+    """Get list of available years from the data."""
+    # For now, generate last 3 years + current year
+    current_year = datetime.now().year
+    years = [str(year) for year in range(current_year - 2, current_year + 1)]
+    years.reverse()  # Most recent first
+    years.append("All time")
+    return years
+
+
+def interactive_mode() -> dict:
+    """Run interactive mode to collect user preferences.
+
+    Returns:
+        Dictionary with user selections: {
+            'year': str,
+            'html': bool,
+            'markdown': bool,
+            'json': bool,
+            'no_animate': bool,
+            'output': str | None
+        }
+    """
+    console = Console()
+
+    # Welcome message
+    console.print()
+    console.print("  [bold #E67E22]Claude Code Wrapped[/bold #E67E22] [dim]- Interactive Mode[/dim]")
+    console.print()
+
+    try:
+        # 1. Select time period
+        year_choices = get_available_years()
+        year_answer = questionary.select(
+            "Select time period:",
+            choices=year_choices,
+            style=custom_style,
+            use_shortcuts=True,
+            use_arrow_keys=True,
+        ).ask()
+
+        if year_answer is None:  # User pressed Ctrl+C
+            console.print("\n[yellow]Cancelled.[/yellow]")
+            sys.exit(0)
+
+        # Convert "All time" to "all" for internal use
+        year = "all" if year_answer == "All time" else year_answer
+
+        # 2. Select export format
+        export_answer = questionary.select(
+            "Export format:",
+            choices=[
+                "View in terminal only",
+                "Export to HTML",
+                "Export to Markdown",
+                "Export to both HTML & Markdown",
+                "Export to JSON",
+            ],
+            style=custom_style,
+            default="View in terminal only",
+        ).ask()
+
+        if export_answer is None:
+            console.print("\n[yellow]Cancelled.[/yellow]")
+            sys.exit(0)
+
+        # Parse export selections
+        html = "HTML" in export_answer
+        markdown = "Markdown" in export_answer
+        json_export = "JSON" in export_answer
+
+        # 3. Ask about animations (only if viewing in terminal)
+        if export_answer == "View in terminal only" or html or markdown:
+            animate_answer = questionary.confirm(
+                "Show animations?",
+                default=True,
+                style=custom_style,
+            ).ask()
+
+            if animate_answer is None:
+                console.print("\n[yellow]Cancelled.[/yellow]")
+                sys.exit(0)
+
+            no_animate = not animate_answer
+        else:
+            no_animate = True  # Skip animations for JSON-only export
+
+        # 4. Custom filename (only if exporting)
+        output_filename = None
+        if html or markdown or json_export:
+            use_custom = questionary.confirm(
+                "Use custom filename?",
+                default=False,
+                style=custom_style,
+            ).ask()
+
+            if use_custom is None:
+                console.print("\n[yellow]Cancelled.[/yellow]")
+                sys.exit(0)
+
+            if use_custom:
+                output_filename = questionary.text(
+                    "Enter filename (without extension):",
+                    style=custom_style,
+                    validate=lambda text: len(text) > 0 or "Filename cannot be empty",
+                ).ask()
+
+                if output_filename is None:
+                    console.print("\n[yellow]Cancelled.[/yellow]")
+                    sys.exit(0)
+
+        console.print()  # Add spacing before execution
+
+        return {
+            'year': year,
+            'html': html,
+            'markdown': markdown,
+            'json': json_export,
+            'no_animate': no_animate,
+            'output': output_filename,
+        }
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Cancelled.[/yellow]")
+        sys.exit(0)
+
+
+def should_use_interactive_mode() -> bool:
+    """Determine if we should use interactive mode.
+
+    Interactive mode is used when:
+    - No arguments provided at all (just `claude-wrapped`)
+    - Only the --interactive flag is provided
+    """
+    # Check if only the script name is in argv (no arguments)
+    if len(sys.argv) == 1:
+        return True
+
+    # Check if only --interactive flag is provided
+    if len(sys.argv) == 2 and sys.argv[1] in ['--interactive', '-i']:
+        return True
+
+    return False