claude-code-wrapped 0.1.5 → 0.1.7

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:api.github.com)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:raw.githubusercontent.com)"
+    ]
+  }
+}

package/claude_code_wrapped/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Wrapped - Your year with Claude Code, Spotify Wrapped style."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.7"

package/claude_code_wrapped/main.py

@@ -87,11 +87,31 @@ Examples:
             "most_active_day_messages": stats.most_active_day[1] if stats.most_active_day else None,
             "primary_model": stats.primary_model,
             "top_tools": dict(stats.top_tools),
+            "top_mcps": dict(stats.top_mcps),
             "top_projects": dict(stats.top_projects),
             "hourly_distribution": stats.hourly_distribution,
             "weekday_distribution": stats.weekday_distribution,
             "estimated_cost_usd": stats.estimated_cost,
             "cost_by_model": stats.cost_by_model,
+            # Averages
+            "avg_messages_per_day": round(stats.avg_messages_per_day, 1),
+            "avg_messages_per_week": round(stats.avg_messages_per_week, 1),
+            "avg_messages_per_month": round(stats.avg_messages_per_month, 1),
+            "avg_cost_per_day": round(stats.avg_cost_per_day, 2) if stats.avg_cost_per_day else None,
+            "avg_cost_per_week": round(stats.avg_cost_per_week, 2) if stats.avg_cost_per_week else None,
+            "avg_cost_per_month": round(stats.avg_cost_per_month, 2) if stats.avg_cost_per_month else None,
+            # Code activity
+            "total_edits": stats.total_edits,
+            "total_writes": stats.total_writes,
+            "avg_code_changes_per_day": round(stats.avg_edits_per_day, 1),
+            "avg_code_changes_per_week": round(stats.avg_edits_per_week, 1),
+            # Monthly breakdown
+            "monthly_costs": stats.monthly_costs,
+            "monthly_tokens": stats.monthly_tokens,
+            # Longest conversation
+            "longest_conversation_messages": stats.longest_conversation_messages,
+            "longest_conversation_tokens": stats.longest_conversation_tokens,
+            "longest_conversation_date": stats.longest_conversation_date.isoformat() if stats.longest_conversation_date else None,
         }
         print(json.dumps(output, indent=2))
     else:

package/claude_code_wrapped/stats.py

@@ -52,6 +52,10 @@ class WrappedStats:
     tool_calls: Counter = field(default_factory=Counter)
     top_tools: list[tuple[str, int]] = field(default_factory=list)
 
+    # MCP server usage (extracted from mcp__server__tool format)
+    mcp_servers: Counter = field(default_factory=Counter)
+    top_mcps: list[tuple[str, int]] = field(default_factory=list)
+
     # Model usage
     models_used: Counter = field(default_factory=Counter)
     primary_model: str | None = None
@@ -71,14 +75,39 @@ class WrappedStats:
 
     # Fun stats
     longest_conversation_tokens: int = 0
-    avg_messages_per_day: float = 0.0
     avg_tokens_per_message: float = 0.0
 
+    # Averages (messages)
+    avg_messages_per_day: float = 0.0
+    avg_messages_per_week: float = 0.0
+    avg_messages_per_month: float = 0.0
+
+    # Averages (cost)
+    avg_cost_per_day: float = 0.0
+    avg_cost_per_week: float = 0.0
+    avg_cost_per_month: float = 0.0
+
+    # Code activity (from Edit/Write tools)
+    total_edits: int = 0
+    total_writes: int = 0
+    avg_edits_per_day: float = 0.0
+    avg_edits_per_week: float = 0.0
+
     # Cost tracking (per model)
     model_token_usage: dict[str, dict[str, int]] = field(default_factory=dict)
     estimated_cost: float | None = None
     cost_by_model: dict[str, float] = field(default_factory=dict)
 
+    # Monthly breakdown for cost table
+    monthly_costs: dict[str, float] = field(default_factory=dict)  # "YYYY-MM" -> cost
+    monthly_tokens: dict[str, dict[str, int]] = field(default_factory=dict)  # "YYYY-MM" -> {input, output, ...}
+
+    # Longest conversation tracking
+    longest_conversation_messages: int = 0
+    longest_conversation_tokens: int = 0
+    longest_conversation_session: str | None = None
+    longest_conversation_date: datetime | None = None
+
     @property
     def total_tokens(self) -> int:
         return (
@@ -163,6 +192,19 @@ def aggregate_stats(messages: list[Message], year: int) -> WrappedStats:
     projects = Counter()
     daily = defaultdict(lambda: DailyStats(date=datetime.now()))
 
+    # Track monthly token usage for cost breakdown
+    monthly_tokens: dict[str, dict[str, int]] = defaultdict(
+        lambda: {"input": 0, "output": 0, "cache_create": 0, "cache_read": 0}
+    )
+    monthly_model_tokens: dict[str, dict[str, dict[str, int]]] = defaultdict(
+        lambda: defaultdict(lambda: {"input": 0, "output": 0, "cache_create": 0, "cache_read": 0})
+    )
+
+    # Track per-session message counts for longest conversation
+    session_messages: dict[str, int] = Counter()
+    session_tokens: dict[str, int] = Counter()
+    session_first_time: dict[str, datetime] = {}
+
     # Process each message
     for msg in messages:
         stats.total_messages += 1
@@ -175,6 +217,10 @@ def aggregate_stats(messages: list[Message], year: int) -> WrappedStats:
         # Session tracking
         if msg.session_id:
             sessions.add(msg.session_id)
+            session_messages[msg.session_id] += 1
+            # Track first timestamp for each session
+            if msg.session_id not in session_first_time and msg.timestamp:
+                session_first_time[msg.session_id] = msg.timestamp
 
         # Project tracking
         project_name = extract_project_name(msg.project)
@@ -218,9 +264,35 @@ def aggregate_stats(messages: list[Message], year: int) -> WrappedStats:
                 stats.model_token_usage[raw_model]["cache_create"] += msg.usage.cache_creation_tokens
                 stats.model_token_usage[raw_model]["cache_read"] += msg.usage.cache_read_tokens
 
-        # Tool usage
+            # Track monthly token usage for cost breakdown
+            if msg.timestamp:
+                month_key = msg.timestamp.strftime("%Y-%m")
+                monthly_tokens[month_key]["input"] += msg.usage.input_tokens
+                monthly_tokens[month_key]["output"] += msg.usage.output_tokens
+                monthly_tokens[month_key]["cache_create"] += msg.usage.cache_creation_tokens
+                monthly_tokens[month_key]["cache_read"] += msg.usage.cache_read_tokens
+
+                # Also track per-model per-month for accurate cost calculation
+                if raw_model and raw_model != '<synthetic>':
+                    monthly_model_tokens[month_key][raw_model]["input"] += msg.usage.input_tokens
+                    monthly_model_tokens[month_key][raw_model]["output"] += msg.usage.output_tokens
+                    monthly_model_tokens[month_key][raw_model]["cache_create"] += msg.usage.cache_creation_tokens
+                    monthly_model_tokens[month_key][raw_model]["cache_read"] += msg.usage.cache_read_tokens
+
+            # Track per-session tokens for longest conversation
+            if msg.session_id:
+                session_tokens[msg.session_id] += msg.usage.total_tokens
+
+        # Tool usage (separate MCPs from regular tools)
         for tool in msg.tool_calls:
-            stats.tool_calls[tool] += 1
+            if tool.startswith("mcp__"):
+                # Extract MCP server name: mcp__servername__toolname -> servername
+                parts = tool.split("__")
+                if len(parts) >= 2:
+                    mcp_server = parts[1]
+                    stats.mcp_servers[mcp_server] += 1
+            else:
+                stats.tool_calls[tool] += 1
 
         # Time-based stats
         if msg.timestamp:
@@ -270,6 +342,9 @@ def aggregate_stats(messages: list[Message], year: int) -> WrappedStats:
     # Top tools
     stats.top_tools = stats.tool_calls.most_common(10)
 
+    # Top MCPs
+    stats.top_mcps = stats.mcp_servers.most_common(5)
+
     # Top projects
     stats.top_projects = projects.most_common(5)
 
@@ -280,20 +355,62 @@ def aggregate_stats(messages: list[Message], year: int) -> WrappedStats:
     # Streaks
     stats.streak_longest, stats.streak_current = calculate_streaks(daily, year)
 
-    # Averages
-    if stats.active_days > 0:
-        stats.avg_messages_per_day = stats.total_messages / stats.active_days
-
-    if stats.total_assistant_messages > 0:
-        stats.avg_tokens_per_message = stats.total_tokens / stats.total_assistant_messages
-
-    # Calculate estimated cost
+    # Calculate estimated cost first (needed for averages)
     from .pricing import calculate_total_cost_by_model
     if stats.model_token_usage:
         stats.estimated_cost, stats.cost_by_model = calculate_total_cost_by_model(
             stats.model_token_usage
         )
 
+    # Calculate monthly costs
+    stats.monthly_tokens = dict(monthly_tokens)
+    for month_key, model_usage in monthly_model_tokens.items():
+        month_cost, _ = calculate_total_cost_by_model(dict(model_usage))
+        stats.monthly_costs[month_key] = month_cost
+
+    # Find longest conversation
+    if session_messages:
+        longest_session = max(session_messages.items(), key=lambda x: x[1])
+        stats.longest_conversation_session = longest_session[0]
+        stats.longest_conversation_messages = longest_session[1]
+        if longest_session[0] in session_tokens:
+            stats.longest_conversation_tokens = session_tokens[longest_session[0]]
+        if longest_session[0] in session_first_time:
+            stats.longest_conversation_date = session_first_time[longest_session[0]]
+
+    # Calculate time periods for averages
+    today = datetime.now()
+    if year == today.year:
+        total_days = (today - datetime(year, 1, 1)).days + 1
+    else:
+        total_days = 366 if year % 4 == 0 else 365
+    total_weeks = max(1, total_days / 7)
+    total_months = max(1, total_days / 30.44)  # Average days per month
+
+    # Message averages (over total time period, not just active days)
+    if total_days > 0:
+        stats.avg_messages_per_day = stats.total_messages / total_days
+    stats.avg_messages_per_week = stats.total_messages / total_weeks
+    stats.avg_messages_per_month = stats.total_messages / total_months
+
+    # Cost averages
+    if stats.estimated_cost is not None and total_days > 0:
+        stats.avg_cost_per_day = stats.estimated_cost / total_days
+        stats.avg_cost_per_week = stats.estimated_cost / total_weeks
+        stats.avg_cost_per_month = stats.estimated_cost / total_months
+
+    # Token averages
+    if stats.total_assistant_messages > 0:
+        stats.avg_tokens_per_message = stats.total_tokens / stats.total_assistant_messages
+
+    # Code activity from Edit/Write tools
+    stats.total_edits = stats.tool_calls.get("Edit", 0)
+    stats.total_writes = stats.tool_calls.get("Write", 0)
+    total_code_changes = stats.total_edits + stats.total_writes
+    if total_days > 0:
+        stats.avg_edits_per_day = total_code_changes / total_days
+        stats.avg_edits_per_week = total_code_changes / total_weeks
+
     return stats
 
 

package/claude_code_wrapped/ui.py

@@ -52,7 +52,7 @@ def wait_for_keypress():
         return '\n'
 
 
-def create_dramatic_stat(value: str, label: str, subtitle: str = "", color: str = COLORS["orange"]) -> Text:
+def create_dramatic_stat(value: str, label: str, subtitle: str = "", color: str = COLORS["orange"], extra_lines: list[tuple[str, str]] = None) -> Text:
     """Create a dramatic full-screen stat reveal."""
     text = Text()
     text.append("\n\n\n\n\n")
@@ -60,6 +60,10 @@ def create_dramatic_stat(value: str, label: str, subtitle: str = "", color: str
     text.append(f"{label}\n\n", style=Style(color=COLORS["white"], bold=True))
     if subtitle:
         text.append(subtitle, style=Style(color=COLORS["gray"]))
+    if extra_lines:
+        text.append("\n\n")
+        for line, line_color in extra_lines:
+            text.append(f"{line}\n", style=Style(color=line_color))
     text.append("\n\n\n\n")
     text.append("press [ENTER] to continue", style=Style(color=COLORS["dark"]))
     return text
@@ -277,12 +281,12 @@ def determine_personality(stats: WrappedStats) -> dict:
 
 
 def get_fun_facts(stats: WrappedStats) -> list[tuple[str, str]]:
-    """Generate fun facts / bloopers based on stats."""
+    """Generate fun facts / bloopers based on stats - only 3 key facts."""
     facts = []
 
-    # Late night coding
+    # Late night coding (midnight to 5am)
     late_night = sum(stats.hourly_distribution[0:5])
-    if late_night > 100:
+    if late_night > 0:
         facts.append(("🌙", f"You coded after midnight {late_night:,} times. Sleep is overrated."))
 
     # Most active day insight
@@ -290,35 +294,11 @@ def get_fun_facts(stats: WrappedStats) -> list[tuple[str, str]]:
         day_name = stats.most_active_day[0].strftime("%A")
         facts.append(("📅", f"Your biggest day was a {day_name}. {stats.most_active_day[1]:,} messages. Epic."))
 
-    # Tool obsession
-    if stats.top_tools:
-        top_tool, count = stats.top_tools[0]
-        facts.append(("🔧", f"You used {top_tool} {count:,} times. It's basically muscle memory now."))
-
-    # If they use Opus a lot
-    opus_count = stats.models_used.get("Opus", 0)
-    if opus_count > 1000:
-        facts.append(("🎭", f"You summoned Opus {opus_count:,} times. Only the best for you."))
-
     # Streak fact
-    if stats.streak_longest >= 7:
+    if stats.streak_longest >= 1:
         facts.append(("🔥", f"Your {stats.streak_longest}-day streak was legendary. Consistency wins."))
 
-    # Multi-project
-    if stats.total_projects >= 3:
-        facts.append(("🏗️", f"You juggled {stats.total_projects} projects. Multitasking champion."))
-
-    # Token usage perspective
-    if stats.total_tokens > 1_000_000_000:
-        books = stats.total_tokens // 100_000  # ~100k tokens per book
-        facts.append(("📚", f"You processed enough tokens for ~{books:,} books. Wow."))
-
-    # Weekend warrior
-    weekend = stats.weekday_distribution[5] + stats.weekday_distribution[6]
-    if weekend > 1000:
-        facts.append(("🏖️", f"Even weekends weren't safe. {weekend:,} weekend messages."))
-
-    return facts[:5]  # Limit to 5 facts
+    return facts
 
 
 def create_fun_facts_slide(facts: list[tuple[str, str]]) -> Text:
@@ -357,6 +337,70 @@ def simplify_model_name(model: str) -> str:
     return model
 
 
+def create_monthly_cost_table(stats: WrappedStats) -> Panel:
+    """Create a monthly cost breakdown table like ccusage."""
+    from .pricing import format_cost
+
+    table = Table(
+        show_header=True,
+        header_style=Style(color=COLORS["white"], bold=True),
+        border_style=Style(color=COLORS["dark"]),
+        box=None,
+        padding=(0, 1),
+    )
+
+    table.add_column("Month", style=Style(color=COLORS["gray"]))
+    table.add_column("Input", justify="right", style=Style(color=COLORS["blue"]))
+    table.add_column("Output", justify="right", style=Style(color=COLORS["orange"]))
+    table.add_column("Cache", justify="right", style=Style(color=COLORS["purple"]))
+    table.add_column("Cost", justify="right", style=Style(color=COLORS["green"], bold=True))
+
+    # Sort months chronologically
+    sorted_months = sorted(stats.monthly_costs.keys())
+
+    for month_key in sorted_months:
+        cost = stats.monthly_costs.get(month_key, 0)
+        tokens = stats.monthly_tokens.get(month_key, {})
+
+        # Format month name
+        try:
+            month_date = datetime.strptime(month_key, "%Y-%m")
+            month_name = month_date.strftime("%b %Y")
+        except ValueError:
+            month_name = month_key
+
+        input_tokens = tokens.get("input", 0)
+        output_tokens = tokens.get("output", 0)
+        cache_tokens = tokens.get("cache_create", 0) + tokens.get("cache_read", 0)
+
+        table.add_row(
+            month_name,
+            format_tokens(input_tokens),
+            format_tokens(output_tokens),
+            format_tokens(cache_tokens),
+            format_cost(cost),
+        )
+
+    # Add total row
+    if sorted_months:
+        table.add_row("", "", "", "", "")  # Separator
+        table.add_row(
+            "Total",
+            format_tokens(stats.total_input_tokens),
+            format_tokens(stats.total_output_tokens),
+            format_tokens(stats.total_cache_creation_tokens + stats.total_cache_read_tokens),
+            format_cost(stats.estimated_cost) if stats.estimated_cost else "N/A",
+            style=Style(bold=True),
+        )
+
+    return Panel(
+        table,
+        title="Monthly Cost Breakdown",
+        border_style=Style(color=COLORS["green"]),
+        padding=(0, 1),
+    )
+
+
 def create_credits_roll(stats: WrappedStats) -> list[Text]:
     """Create end credits content."""
     from .pricing import format_cost
@@ -413,7 +457,59 @@ def create_credits_roll(stats: WrappedStats) -> list[Text]:
     timeline.append("    [ENTER]", style=Style(color=COLORS["dark"]))
     frames.append(timeline)
 
-    # Frame 3: Cast (models)
+    # Frame 3: Averages
+    from .pricing import format_cost
+    averages = Text()
+    averages.append("\n\n\n")
+    averages.append("              A V E R A G E S\n\n", style=Style(color=COLORS["blue"], bold=True))
+    averages.append("              Messages\n", style=Style(color=COLORS["white"], bold=True))
+    averages.append(f"                Per day:   {stats.avg_messages_per_day:.1f}\n", style=Style(color=COLORS["gray"]))
+    averages.append(f"                Per week:  {stats.avg_messages_per_week:.1f}\n", style=Style(color=COLORS["gray"]))
+    averages.append(f"                Per month: {stats.avg_messages_per_month:.1f}\n", style=Style(color=COLORS["gray"]))
+    if stats.estimated_cost is not None:
+        averages.append("\n              Cost\n", style=Style(color=COLORS["white"], bold=True))
+        averages.append(f"                Per day:   {format_cost(stats.avg_cost_per_day)}\n", style=Style(color=COLORS["gray"]))
+        averages.append(f"                Per week:  {format_cost(stats.avg_cost_per_week)}\n", style=Style(color=COLORS["gray"]))
+        averages.append(f"                Per month: {format_cost(stats.avg_cost_per_month)}\n", style=Style(color=COLORS["gray"]))
+    averages.append("\n\n")
+    averages.append("    [ENTER]", style=Style(color=COLORS["dark"]))
+    frames.append(averages)
+
+    # Frame 4: Code Activity
+    code_activity = Text()
+    code_activity.append("\n\n\n")
+    code_activity.append("              C O D E   A C T I V I T Y\n\n", style=Style(color=COLORS["orange"], bold=True))
+    total_code_changes = stats.total_edits + stats.total_writes
+    code_activity.append("              File Changes\n", style=Style(color=COLORS["white"], bold=True))
+    code_activity.append(f"                Edits:  {stats.total_edits:,}\n", style=Style(color=COLORS["gray"]))
+    code_activity.append(f"                Writes: {stats.total_writes:,}\n", style=Style(color=COLORS["gray"]))
+    code_activity.append(f"                Total:  {total_code_changes:,}\n", style=Style(color=COLORS["orange"], bold=True))
+    code_activity.append("\n              Averages\n", style=Style(color=COLORS["white"], bold=True))
+    code_activity.append(f"                Per day:  {stats.avg_edits_per_day:.1f}\n", style=Style(color=COLORS["gray"]))
+    code_activity.append(f"                Per week: {stats.avg_edits_per_week:.1f}\n", style=Style(color=COLORS["gray"]))
+    code_activity.append("\n\n")
+    code_activity.append("    [ENTER]", style=Style(color=COLORS["dark"]))
+    frames.append(code_activity)
+
+    # Frame 5: Longest Conversation
+    if stats.longest_conversation_messages > 0:
+        longest = Text()
+        longest.append("\n\n\n")
+        longest.append("              L O N G E S T   C O N V E R S A T I O N\n\n", style=Style(color=COLORS["purple"], bold=True))
+        longest.append(f"              Messages  ", style=Style(color=COLORS["white"], bold=True))
+        longest.append(f"{stats.longest_conversation_messages:,}\n", style=Style(color=COLORS["purple"], bold=True))
+        if stats.longest_conversation_tokens > 0:
+            longest.append(f"              Tokens    ", style=Style(color=COLORS["white"], bold=True))
+            longest.append(f"{format_tokens(stats.longest_conversation_tokens)}\n", style=Style(color=COLORS["orange"], bold=True))
+        if stats.longest_conversation_date:
+            longest.append(f"              Date      ", style=Style(color=COLORS["white"], bold=True))
+            longest.append(f"{stats.longest_conversation_date.strftime('%B %d, %Y')}\n", style=Style(color=COLORS["gray"]))
+        longest.append("\n              That's one epic coding session!\n", style=Style(color=COLORS["gray"]))
+        longest.append("\n\n")
+        longest.append("    [ENTER]", style=Style(color=COLORS["dark"]))
+        frames.append(longest)
+
+    # Frame 6: Cast (models)
     cast = Text()
     cast.append("\n\n\n")
     cast.append("              S T A R R I N G\n\n", style=Style(color=COLORS["purple"], bold=True))
@@ -424,7 +520,7 @@ def create_credits_roll(stats: WrappedStats) -> list[Text]:
     cast.append("    [ENTER]", style=Style(color=COLORS["dark"]))
     frames.append(cast)
 
-    # Frame 4: Projects
+    # Frame 6: Projects
     if stats.top_projects:
         projects = Text()
         projects.append("\n\n\n")
@@ -479,29 +575,72 @@ def render_wrapped(stats: WrappedStats, console: Console | None = None, animate:
         wait_for_keypress()
         console.clear()
 
-        # Dramatic stat reveals
-        slides = [
-            (f"{stats.total_messages:,}", "MESSAGES", "conversations with Claude", COLORS["orange"]),
-            (str(stats.total_sessions), "SESSIONS", "coding adventures", COLORS["purple"]),
-            (format_tokens(stats.total_tokens), "TOKENS", "processed through the AI", COLORS["green"]),
-            (f"{stats.streak_longest}", "DAY STREAK", "your longest run", COLORS["blue"]),
-        ]
+        # Slide 1: Messages with date range
+        first_date = stats.first_message_date.strftime("%d %B") if stats.first_message_date else "the beginning"
+        last_date = stats.last_message_date.strftime("%d %B %Y") if stats.last_message_date else "today"
+        messages_subtitle = f"From {first_date} to {last_date}"
+        console.print(Align.center(create_dramatic_stat(
+            f"{stats.total_messages:,}", "MESSAGES", messages_subtitle, COLORS["orange"]
+        )))
+        wait_for_keypress()
+        console.clear()
 
-        for value, label, subtitle, color in slides:
-            console.print(Align.center(create_dramatic_stat(value, label, subtitle, color)))
-            wait_for_keypress()
-            console.clear()
+        # Slide 2: Averages
+        from .pricing import format_cost
+        averages_text = Text()
+        averages_text.append("\n\n\n\n")
+        averages_text.append("On average, you sent\n\n", style=Style(color=COLORS["gray"]))
+        averages_text.append(f"{stats.avg_messages_per_day:.0f}", style=Style(color=COLORS["orange"], bold=True))
+        averages_text.append(" messages per day\n", style=Style(color=COLORS["white"]))
+        averages_text.append(f"{stats.avg_messages_per_week:.0f}", style=Style(color=COLORS["blue"], bold=True))
+        averages_text.append(" messages per week\n", style=Style(color=COLORS["white"]))
+        averages_text.append(f"{stats.avg_messages_per_month:.0f}", style=Style(color=COLORS["purple"], bold=True))
+        averages_text.append(" messages per month\n\n", style=Style(color=COLORS["white"]))
+        if stats.estimated_cost is not None:
+            averages_text.append("Costing about ", style=Style(color=COLORS["gray"]))
+            averages_text.append(f"{format_cost(stats.avg_cost_per_day)}/day", style=Style(color=COLORS["green"], bold=True))
+            averages_text.append(f" · {format_cost(stats.avg_cost_per_week)}/week", style=Style(color=COLORS["green"]))
+            averages_text.append(f" · {format_cost(stats.avg_cost_per_month)}/month\n", style=Style(color=COLORS["green"]))
+        averages_text.append("\n\n\n")
+        averages_text.append("press [ENTER] to continue", style=Style(color=COLORS["dark"]))
+        console.print(Align.center(averages_text))
+        wait_for_keypress()
+        console.clear()
+
+        # Slide 3: Tokens
+        def format_tokens_dramatic(tokens: int) -> str:
+            if tokens >= 1_000_000_000:
+                return f"{tokens / 1_000_000_000:.1f} Bn"
+            if tokens >= 1_000_000:
+                return f"{tokens / 1_000_000:.0f} M"
+            if tokens >= 1_000:
+                return f"{tokens / 1_000:.0f} K"
+            return str(tokens)
+
+        tokens_text = Text()
+        tokens_text.append("\n\n\n\n\n")
+        tokens_text.append("That's\n\n", style=Style(color=COLORS["gray"]))
+        tokens_text.append(f"{format_tokens_dramatic(stats.total_tokens)}\n", style=Style(color=COLORS["green"], bold=True))
+        tokens_text.append("TOKENS\n\n", style=Style(color=COLORS["white"], bold=True))
+        tokens_text.append("processed through the AI", style=Style(color=COLORS["gray"]))
+        tokens_text.append("\n\n\n\n")
+        tokens_text.append("press [ENTER] to continue", style=Style(color=COLORS["dark"]))
+        console.print(Align.center(tokens_text))
+        wait_for_keypress()
+        console.clear()
 
-        # Personality reveal
+        # Slide 4: Streak + Personality (merged)
         personality = determine_personality(stats)
-        personality_text = Text()
-        personality_text.append("\n\n\n\n")
-        personality_text.append(f"  {personality['emoji']}\n\n", style=Style(bold=True))
-        personality_text.append(f"  You are\n", style=Style(color=COLORS["gray"]))
-        personality_text.append(f"  {personality['title']}\n\n", style=Style(color=COLORS["purple"], bold=True))
-        personality_text.append(f"  {personality['description']}\n\n\n", style=Style(color=COLORS["white"]))
-        personality_text.append("  [ENTER]", style=Style(color=COLORS["dark"]))
-        console.print(Align.center(personality_text))
+        streak_text = Text()
+        streak_text.append("\n\n\n\n")
+        streak_text.append(f"{stats.streak_longest}\n", style=Style(color=COLORS["blue"], bold=True))
+        streak_text.append("DAY STREAK\n\n", style=Style(color=COLORS["white"], bold=True))
+        streak_text.append(f"{personality['emoji']}  ", style=Style(bold=True))
+        streak_text.append(f"{personality['title']}\n", style=Style(color=COLORS["purple"], bold=True))
+        streak_text.append(f"{personality['description']}\n", style=Style(color=COLORS["gray"]))
+        streak_text.append("\n\n\n")
+        streak_text.append("press [ENTER] to continue", style=Style(color=COLORS["dark"]))
+        console.print(Align.center(streak_text))
         wait_for_keypress()
         console.clear()
 
@@ -559,6 +698,14 @@ def render_wrapped(stats: WrappedStats, console: Console | None = None, animate:
     )
     console.print(lists)
 
+    # MCPs (if any)
+    if stats.top_mcps:
+        console.print(create_top_list(stats.top_mcps, "MCP Servers", COLORS["purple"]))
+
+    # Monthly cost table
+    if stats.monthly_costs:
+        console.print(create_monthly_cost_table(stats))
+
     # Insights
     insights = Text()
     if stats.most_active_day:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-wrapped",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Your year with Claude Code - Spotify Wrapped style terminal experience",
   "bin": {
     "claude-code-wrapped": "./bin/cli.js"

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-wrapped"
-version = "0.1.5"
+version = "0.1.7"
 description = "Your year with Claude Code - Spotify Wrapped style terminal experience"
 readme = "README.md"
 requires-python = ">=3.12"

package/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.12"
 
 [[package]]
 name = "claude-code-wrapped"
-version = "0.1.4"
+version = "0.1.6"
 source = { editable = "." }
 dependencies = [
     { name = "rich" },