@da-trollefsen/claude-wrapped 1.0.0

package/claude_code_wrapped/main.py

@@ -0,0 +1,203 @@
+"""Claude Code Wrapped - Main entry point."""
+
+import argparse
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Console
+
+from .reader import get_claude_dir, load_all_messages
+from .stats import aggregate_stats
+from .ui import render_wrapped
+from .exporters import export_to_html, export_to_markdown
+from .interactive import interactive_mode, should_use_interactive_mode
+
+
+def main():
+    """Main entry point for Claude Code Wrapped."""
+    # Check if we should use interactive mode
+    if should_use_interactive_mode():
+        # Get user selections through interactive prompts
+        selections = interactive_mode()
+
+        # Create args namespace from interactive selections
+        args = argparse.Namespace(
+            year=selections['year'],
+            no_animate=selections['no_animate'],
+            json=selections['json'],
+            html=selections['html'],
+            markdown=selections['markdown'],
+            output=selections['output'],
+        )
+    else:
+        # Use traditional CLI argument parsing
+        parser = argparse.ArgumentParser(
+            description="Claude Code Wrapped - Your year with Claude Code",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+            epilog="""
+Examples:
+  claude-wrapped                Interactive mode (prompts for all options)
+  claude-wrapped 2025           Show your 2025 wrapped
+  claude-wrapped all            Show your all-time wrapped
+  claude-wrapped --no-animate   Skip animations
+  claude-wrapped --html         Export to HTML file
+  claude-wrapped --markdown     Export to Markdown file
+  claude-wrapped all --html --markdown  Export all-time stats to both formats
+            """,
+        )
+        parser.add_argument(
+            "year",
+            type=str,
+            nargs="?",
+            default=str(datetime.now().year),
+            help="Year to analyze or 'all' for all-time stats (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",
+        )
+        parser.add_argument(
+            "--html",
+            action="store_true",
+            help="Export to HTML file",
+        )
+        parser.add_argument(
+            "--markdown",
+            action="store_true",
+            help="Export to Markdown file",
+        )
+        parser.add_argument(
+            "--output",
+            type=str,
+            help="Custom output filename (without extension)",
+        )
+        parser.add_argument(
+            "-i", "--interactive",
+            action="store_true",
+            help="Launch interactive mode (default when no arguments provided)",
+        )
+
+        args = parser.parse_args()
+    console = Console()
+
+    # Parse year argument
+    if args.year.lower() == "all":
+        year_filter = None
+        year_display = "all-time"
+        year_label = "All time"
+    else:
+        try:
+            year_filter = int(args.year)
+            year_display = str(year_filter)
+            year_label = str(year_filter)
+        except ValueError:
+            console.print(f"[red]Error:[/red] Invalid year '{args.year}'. Use a year (e.g., 2025) or 'all'.")
+            sys.exit(1)
+
+    # 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 {year_label}...[/dim]\n")
+
+    messages = load_all_messages(claude_dir, year=year_filter)
+
+    if not messages:
+        console.print(f"[yellow]No Claude Code activity found for {year_label}.[/yellow]")
+        console.print("\nTry a different year or make sure you've used Claude Code.")
+        sys.exit(0)
+
+    # Calculate stats
+    stats = aggregate_stats(messages, year_filter)
+
+    # Generate timestamp for filenames
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M")
+
+    # Export to HTML if requested
+    if args.html:
+        if args.output:
+            output_name = args.output
+        else:
+            output_name = f"claude-wrapped-{year_display}-{timestamp}"
+        html_path = Path(f"{output_name}.html")
+        export_to_html(stats, year_filter, html_path)
+        console.print(f"\n[green]✓[/green] Exported to [bold]{html_path}[/bold]")
+
+    # Export to Markdown if requested
+    if args.markdown:
+        if args.output:
+            output_name = args.output
+        else:
+            output_name = f"claude-wrapped-{year_display}-{timestamp}"
+        md_path = Path(f"{output_name}.md")
+        export_to_markdown(stats, year_filter, md_path)
+        console.print(f"\n[green]✓[/green] Exported to [bold]{md_path}[/bold]")
+
+    # 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,
+            "late_night_days": stats.late_night_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_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:
+        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)}")