claude-code-wrapped 0.1.2

package/.python-version

@@ -0,0 +1 @@
+3.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mert Deveci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# Claude Code Wrapped
+
+```
+  ░█████╗░██╗░░░░░░█████╗░██╗░░░██╗██████╗░███████╗
+  ██╔══██╗██║░░░░░██╔══██╗██║░░░██║██╔══██╗██╔════╝
+  ██║░░╚═╝██║░░░░░███████║██║░░░██║██║░░██║█████╗░░
+  ██║░░██╗██║░░░░░██╔══██║██║░░░██║██║░░██║██╔══╝░░
+  ╚█████╔╝███████╗██║░░██║╚██████╔╝██████╔╝███████╗
+  ░╚════╝░╚══════╝╚═╝░░╚═╝░╚═════╝░╚═════╝░╚══════╝
+
+            C O D E   W R A P P E D   2025
+                    by Banker.so
+```
+
+Your year with Claude Code, Spotify Wrapped style.
+
+## Installation
+
+```bash
+# Using uvx (recommended)
+uvx claude-code-wrapped
+
+# Using npx
+npx claude-code-wrapped
+
+# Or install via pip
+pip install claude-code-wrapped
+claude-code-wrapped
+```
+
+Press `Enter` to advance through your personalized stats.
+
+## What You'll See
+
+**Dramatic stat reveals** - one at a time, like Spotify Wrapped:
+- Total messages exchanged
+- Coding sessions
+- Tokens processed
+- Your longest streak
+
+**GitHub-style contribution graph** - see your coding patterns at a glance
+
+**Your coding personality** - based on your habits:
+- 🦉 Night Owl
+- 🔥 Streak Master
+- ⚡ Terminal Warrior
+- 🎨 The Refactorer
+- 🚀 Empire Builder
+- 🌙 Weekend Warrior
+- 🎯 Perfectionist
+- 💻 Dedicated Dev
+
+**Fun facts & bloopers** - like "You coded after midnight 47 times"
+
+**Movie-style credits** - featuring your top tools, projects, and models
+
+## Options
+
+```bash
+claude-code-wrapped              # Full cinematic experience
+claude-code-wrapped --no-animate # Skip to dashboard view
+claude-code-wrapped --json       # Export stats as JSON
+claude-code-wrapped 2025         # View a specific year
+```
+
+## Requirements
+
+- Python 3.12+ (with uvx, pipx, or pip)
+- Or Node.js 16+ (for npx)
+- Claude Code installed (`~/.claude/` directory exists)
+
+## How It Works
+
+Reads your local Claude Code conversation history from `~/.claude/projects/` and aggregates:
+- Message counts and timestamps
+- Token usage (input, output, cache)
+- Tool usage (Bash, Read, Edit, etc.)
+- Model preferences (Opus, Sonnet, Haiku)
+- Project activity
+
+All data stays local. Nothing is sent anywhere.
+
+## Privacy
+
+This tool is completely local and privacy-focused:
+
+- **No network requests** - All data is read from your local `~/.claude/` directory
+- **No data collection** - Nothing is sent to any server
+- **No API keys needed** - Works entirely offline
+- **No secrets exposed** - Only aggregated stats are shown, not conversation content
+
+## Author
+
+Built by [Mert Deveci](https://x.com/gm_mertd), Maker of [Banker.so](https://banker.so)
+
+## License
+
+MIT - see [LICENSE](LICENSE) for details.

package/bin/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const { spawn, spawnSync } = require('child_process');
+
+// Pass through all arguments
+const args = process.argv.slice(2);
+
+// Check if a command exists
+function commandExists(cmd) {
+  const result = spawnSync(cmd, ['--version'], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+// Check if Python module is installed
+function pythonModuleExists() {
+  const result = spawnSync('python3', ['-c', 'import claude_code_wrapped'], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+// Try to find the best way to run the Python package
+function findExecutor() {
+  // Try uvx first (recommended)
+  if (commandExists('uvx')) {
+    return { cmd: 'uvx', args: ['claude-code-wrapped', ...args] };
+  }
+
+  // Try pipx
+  if (commandExists('pipx')) {
+    return { cmd: 'pipx', args: ['run', 'claude-code-wrapped', ...args] };
+  }
+
+  // Try direct python module
+  if (pythonModuleExists()) {
+    return { cmd: 'python3', args: ['-m', 'claude_code_wrapped', ...args] };
+  }
+
+  // No executor found
+  console.error('claude-code-wrapped requires Python 3.12+ and one of: uvx, pipx, or pip');
+  console.error('');
+  console.error('Recommended: Install uv (https://docs.astral.sh/uv/) then run:');
+  console.error('  uvx claude-code-wrapped');
+  console.error('');
+  console.error('Or install with pip:');
+  console.error('  pip install claude-code-wrapped');
+  console.error('  claude-code-wrapped');
+  process.exit(1);
+}
+
+const executor = findExecutor();
+const child = spawn(executor.cmd, executor.args, {
+  stdio: 'inherit',
+  env: process.env
+});
+
+child.on('close', (code) => {
+  process.exit(code || 0);
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start:', err.message);
+  process.exit(1);
+});

package/claude_code_wrapped/__init__.py

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

package/claude_code_wrapped/main.py

@@ -0,0 +1,102 @@
+"""Claude Code Wrapped - Main entry point."""
+
+import argparse
+import sys
+from datetime import datetime
+
+from rich.console import Console
+
+from .reader import get_claude_dir, load_all_messages
+from .stats import aggregate_stats
+from .ui import render_wrapped
+
+
+def main():
+    """Main entry point for Claude Code Wrapped."""
+    parser = argparse.ArgumentParser(
+        description="Claude Code Wrapped - Your year with Claude Code",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  claude-code-wrapped              Show your wrapped for current year
+  claude-code-wrapped 2025         Show your 2025 wrapped
+  claude-code-wrapped --no-animate Skip animations
+        """,
+    )
+    parser.add_argument(
+        "year",
+        type=int,
+        nargs="?",
+        default=datetime.now().year,
+        help="Year to analyze (default: current year)",
+    )
+    parser.add_argument(
+        "--no-animate",
+        action="store_true",
+        help="Disable animations for faster display",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output raw stats as JSON",
+    )
+
+    args = parser.parse_args()
+    console = Console()
+
+    # Check for Claude directory
+    try:
+        claude_dir = get_claude_dir()
+    except FileNotFoundError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        console.print("\nMake sure you have Claude Code installed and have used it at least once.")
+        sys.exit(1)
+
+    # Load messages
+    if not args.json:
+        console.print(f"\n[dim]Loading your Claude Code history for {args.year}...[/dim]\n")
+
+    messages = load_all_messages(claude_dir, year=args.year)
+
+    if not messages:
+        console.print(f"[yellow]No Claude Code activity found for {args.year}.[/yellow]")
+        console.print("\nTry a different year or make sure you've used Claude Code.")
+        sys.exit(0)
+
+    # Calculate stats
+    stats = aggregate_stats(messages, args.year)
+
+    # Output
+    if args.json:
+        import json
+        output = {
+            "year": stats.year,
+            "total_messages": stats.total_messages,
+            "total_user_messages": stats.total_user_messages,
+            "total_assistant_messages": stats.total_assistant_messages,
+            "total_sessions": stats.total_sessions,
+            "total_projects": stats.total_projects,
+            "total_tokens": stats.total_tokens,
+            "total_input_tokens": stats.total_input_tokens,
+            "total_output_tokens": stats.total_output_tokens,
+            "active_days": stats.active_days,
+            "streak_longest": stats.streak_longest,
+            "streak_current": stats.streak_current,
+            "most_active_hour": stats.most_active_hour,
+            "most_active_day": stats.most_active_day[0].isoformat() if stats.most_active_day else None,
+            "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_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,
+        }
+        print(json.dumps(output, indent=2))
+    else:
+        render_wrapped(stats, console, animate=not args.no_animate)
+
+
+if __name__ == "__main__":
+    main()

package/claude_code_wrapped/pricing.py

@@ -0,0 +1,179 @@
+"""Pricing data and cost calculation for Claude models.
+
+Based on official Anthropic pricing as of December 2025.
+Source: https://docs.anthropic.com/en/docs/about-claude/models
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelPricing:
+    """Pricing for a Claude model in USD per million tokens."""
+    input_cost: float  # Base input tokens
+    output_cost: float  # Output tokens
+    cache_write_cost: float  # 5-minute cache writes (1.25x input)
+    cache_read_cost: float  # Cache hits & refreshes (0.1x input)
+
+
+# Official Anthropic pricing as of December 2025 (USD per million tokens)
+# Source: https://platform.claude.com/docs/en/about-claude/pricing
+MODEL_PRICING: dict[str, ModelPricing] = {
+    # Claude 4.x models
+    "claude-opus-4-5-20251101": ModelPricing(5.0, 25.0, 6.25, 0.50),
+    "claude-opus-4-20250514": ModelPricing(15.0, 75.0, 18.75, 1.50),
+    "claude-opus-4-1-20250620": ModelPricing(15.0, 75.0, 18.75, 1.50),
+    "claude-sonnet-4-5-20250514": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "claude-sonnet-4-20250514": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "claude-haiku-4-5-20251101": ModelPricing(1.0, 5.0, 1.25, 0.10),
+
+    # Claude 3.x models
+    "claude-3-5-sonnet-20241022": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "claude-3-5-sonnet-20240620": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "claude-3-5-haiku-20241022": ModelPricing(0.80, 4.0, 1.0, 0.08),
+    "claude-3-opus-20240229": ModelPricing(15.0, 75.0, 18.75, 1.50),
+    "claude-3-sonnet-20240229": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "claude-3-haiku-20240307": ModelPricing(0.25, 1.25, 0.30, 0.03),
+}
+
+# Simplified model name mappings for display
+MODEL_FAMILY_PRICING: dict[str, ModelPricing] = {
+    "opus": ModelPricing(15.0, 75.0, 18.75, 1.50),  # Conservative estimate
+    "sonnet": ModelPricing(3.0, 15.0, 3.75, 0.30),
+    "haiku": ModelPricing(0.80, 4.0, 1.0, 0.08),  # Use 3.5 Haiku as default
+}
+
+
+def get_model_pricing(model_name: str | None) -> ModelPricing | None:
+    """Get pricing for a model by name.
+
+    Handles both full model IDs and simplified names like 'Opus', 'Sonnet', 'Haiku'.
+    """
+    if not model_name:
+        return None
+
+    model_lower = model_name.lower()
+
+    # Try exact match first
+    if model_lower in MODEL_PRICING:
+        return MODEL_PRICING[model_lower]
+
+    # For simple names like "Opus", "Sonnet", "Haiku", use family pricing
+    # This is what we get from the stats module's simplified model names
+    for family, pricing in MODEL_FAMILY_PRICING.items():
+        if model_lower == family:
+            return pricing
+
+    # Try partial match on full model IDs (for full model names like "claude-3-5-sonnet-...")
+    for model_id, pricing in MODEL_PRICING.items():
+        if model_lower in model_id or model_id in model_lower:
+            return pricing
+
+    # Fall back to family-based pricing for partial matches
+    for family, pricing in MODEL_FAMILY_PRICING.items():
+        if family in model_lower:
+            return pricing
+
+    return None
+
+
+def calculate_cost(
+    input_tokens: int,
+    output_tokens: int,
+    cache_creation_tokens: int = 0,
+    cache_read_tokens: int = 0,
+    model_name: str | None = None,
+) -> float | None:
+    """Calculate cost in USD for a given token usage.
+
+    Args:
+        input_tokens: Number of input tokens (excluding cache)
+        output_tokens: Number of output tokens
+        cache_creation_tokens: Number of cache write tokens
+        cache_read_tokens: Number of cache read tokens
+        model_name: Model name or ID for pricing lookup
+
+    Returns:
+        Cost in USD, or None if pricing unavailable
+    """
+    pricing = get_model_pricing(model_name)
+    if not pricing:
+        return None
+
+    # Convert to millions and calculate
+    cost = (
+        (input_tokens / 1_000_000) * pricing.input_cost +
+        (output_tokens / 1_000_000) * pricing.output_cost +
+        (cache_creation_tokens / 1_000_000) * pricing.cache_write_cost +
+        (cache_read_tokens / 1_000_000) * pricing.cache_read_cost
+    )
+
+    return cost
+
+
+def calculate_total_cost_by_model(
+    model_usage: dict[str, dict[str, int]]
+) -> tuple[float, dict[str, float]]:
+    """Calculate total cost across all models.
+
+    Args:
+        model_usage: Dict mapping model names to token counts:
+            {
+                "Sonnet": {"input": 1000, "output": 500, "cache_create": 0, "cache_read": 0},
+                "Opus": {"input": 500, "output": 200, ...},
+            }
+
+    Returns:
+        Tuple of (total_cost, per_model_costs)
+    """
+    total = 0.0
+    per_model: dict[str, float] = {}
+
+    for model_name, tokens in model_usage.items():
+        cost = calculate_cost(
+            input_tokens=tokens.get("input", 0),
+            output_tokens=tokens.get("output", 0),
+            cache_creation_tokens=tokens.get("cache_create", 0),
+            cache_read_tokens=tokens.get("cache_read", 0),
+            model_name=model_name,
+        )
+        if cost is not None:
+            per_model[model_name] = cost
+            total += cost
+
+    return total, per_model
+
+
+def format_cost(cost: float | None) -> str:
+    """Format cost for display."""
+    if cost is None:
+        return "N/A"
+    if cost < 0.01:
+        return f"${cost:.4f}"
+    if cost < 1:
+        return f"${cost:.2f}"
+    if cost < 100:
+        return f"${cost:.2f}"
+    if cost < 1000:
+        return f"${cost:.0f}"
+    return f"${cost:,.0f}"
+
+
+if __name__ == "__main__":
+    # Test pricing lookups
+    print("Testing pricing lookups:")
+    test_models = ["Opus", "Sonnet", "Haiku", "claude-3-5-sonnet-20241022", "unknown"]
+    for model in test_models:
+        pricing = get_model_pricing(model)
+        print(f"  {model}: {pricing}")
+
+    # Test cost calculation
+    print("\nTesting cost calculation:")
+    cost = calculate_cost(
+        input_tokens=1_000_000,
+        output_tokens=500_000,
+        cache_creation_tokens=100_000,
+        cache_read_tokens=50_000,
+        model_name="Sonnet"
+    )
+    print(f"  1M input + 500K output + 100K cache create + 50K cache read (Sonnet): {format_cost(cost)}")