claude-code-wrapped 0.1.5 → 0.1.6

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.6"

package/claude_code_wrapped/main.py

@@ -92,6 +92,25 @@ Examples:
             "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

@@ -71,14 +71,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 +188,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 +213,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,6 +260,25 @@ 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
 
+            # 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
         for tool in msg.tool_calls:
             stats.tool_calls[tool] += 1
@@ -280,20 +341,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

@@ -357,6 +357,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 +477,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 +540,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")
@@ -559,6 +675,10 @@ def render_wrapped(stats: WrappedStats, console: Console | None = None, animate:
     )
     console.print(lists)
 
+    # 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.6",
   "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.6"
 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" },