@uxcontinuum/ccwrapped 1.0.0

package/wrapped.py

@@ -0,0 +1,1171 @@
+#!/usr/bin/env python3
+"""
+Claude Code Wrapped — Spotify Wrapped but for your Claude sessions.
+Reads ~/.claude/projects/**/*.jsonl locally. Nothing leaves your machine.
+"""
+
+import json
+import sys
+import os
+import re
+import argparse
+from pathlib import Path
+from datetime import datetime, timedelta, timezone
+from collections import Counter, defaultdict
+import textwrap
+
+def _find_claude_dir() -> Path:
+    candidates = [Path.home() / ".claude" / "projects"]
+    # also check /home/* when running as root (sudo / devbox setups)
+    if Path.home() == Path("/root"):
+        for p in Path("/home").iterdir():
+            alt = p / ".claude" / "projects"
+            if alt not in candidates:
+                candidates.append(alt)
+    for c in candidates:
+        if c.exists() and any(c.rglob("*.jsonl")):
+            return c
+    return candidates[0]
+
+CLAUDE_DIR = _find_claude_dir()
+
+# ANSI colors
+BOLD    = "\033[1m"
+DIM     = "\033[2m"
+RESET   = "\033[0m"
+GREEN   = "\033[92m"
+CYAN    = "\033[96m"
+YELLOW  = "\033[93m"
+MAGENTA = "\033[95m"
+RED     = "\033[91m"
+BLUE    = "\033[94m"
+WHITE   = "\033[97m"
+BG_DARK = "\033[48;5;235m"
+
+
+def color_disabled():
+    global BOLD, DIM, RESET, GREEN, CYAN, YELLOW, MAGENTA, RED, BLUE, WHITE, BG_DARK
+    BOLD = DIM = RESET = GREEN = CYAN = YELLOW = MAGENTA = RED = BLUE = WHITE = BG_DARK = ""
+
+
+def load_sessions(days: int) -> list[dict]:
+    cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+    sessions = []
+    if not CLAUDE_DIR.exists():
+        return sessions
+    for path in CLAUDE_DIR.rglob("*.jsonl"):
+        if "subagents" in str(path):
+            continue
+        mtime = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc)
+        if mtime < cutoff:
+            continue
+        s = parse_session(path, cutoff)
+        if s:
+            sessions.append(s)
+    return sessions
+
+
+def parse_session(path: Path, cutoff: datetime) -> dict | None:
+    lines = []
+    try:
+        lines = path.read_text(errors="replace").splitlines()
+    except Exception:
+        return None
+
+    tool_calls = Counter()
+    user_prompts = []
+    timestamps = []
+    input_tokens = 0
+    output_tokens = 0
+    message_count = 0
+    title = None
+
+    for raw in lines:
+        try:
+            msg = json.loads(raw)
+        except Exception:
+            continue
+
+        if msg.get("type") == "custom-title":
+            title = msg.get("title", "")
+            continue
+
+        if msg.get("type") not in ("user", "assistant"):
+            continue
+
+        ts_str = msg.get("timestamp", "")
+        if ts_str:
+            try:
+                ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                if ts < cutoff:
+                    continue
+                timestamps.append(ts)
+            except Exception:
+                pass
+
+        content = msg.get("message", {}).get("content", [])
+        role = msg.get("type")
+        message_count += 1
+
+        if role == "assistant":
+            usage = msg.get("message", {}).get("usage", {})
+            input_tokens  += usage.get("input_tokens", 0)
+            output_tokens += usage.get("output_tokens", 0)
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_use":
+                        tool_calls[block["name"]] += 1
+
+        if role == "user":
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        text = block.get("text", "").strip()
+                        if text:
+                            user_prompts.append(text)
+
+    if not timestamps:
+        return None
+
+    duration_mins = 0
+    if len(timestamps) >= 2:
+        delta = max(timestamps) - min(timestamps)
+        duration_mins = int(delta.total_seconds() / 60)
+        # cap at 8h — anything longer is a multi-day file, not a real session duration
+        duration_mins = min(duration_mins, 480)
+
+    project = path.parts
+    proj_name = "unknown"
+    for i, part in enumerate(project):
+        if part == "projects" and i + 1 < len(project):
+            raw_proj = project[i + 1]
+            # format: -home-coder-project-name → project-name
+            home_prefix = f"-home-{Path.home().name}-"
+            if raw_proj.startswith(home_prefix):
+                raw_proj = raw_proj[len(home_prefix):]
+            elif raw_proj.startswith("-home-"):
+                raw_proj = raw_proj.lstrip("-")
+            proj_name = raw_proj or "(home)"
+            break
+
+    return {
+        "path": str(path),
+        "project": proj_name,
+        "title": title or "",
+        "tool_calls": tool_calls,
+        "user_prompts": user_prompts,
+        "timestamps": timestamps,
+        "duration_mins": duration_mins,
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "message_count": message_count,
+    }
+
+
+def aggregate(sessions: list[dict]) -> dict:
+    if not sessions:
+        return {}
+
+    total_tools = Counter()
+    all_prompts = []
+    all_timestamps = []
+    projects = Counter()
+    longest = None
+    longest_mins = 0
+
+    for s in sessions:
+        total_tools.update(s["tool_calls"])
+        all_prompts.extend(s["user_prompts"])
+        all_timestamps.extend(s["timestamps"])
+        projects[s["project"]] += 1
+        if s["duration_mins"] > longest_mins:
+            longest_mins = s["duration_mins"]
+            longest = s
+
+    total_tool_calls = sum(total_tools.values())
+    tool_pct = {t: round(100 * c / total_tool_calls) for t, c in total_tools.items()} if total_tool_calls else {}
+
+    hours = Counter(ts.hour for ts in all_timestamps)
+    peak_hour = hours.most_common(1)[0][0] if hours else 12
+    night_count = sum(hours[h] for h in range(22, 24)) + sum(hours[h] for h in range(0, 5))
+    night_pct = round(100 * night_count / len(all_timestamps)) if all_timestamps else 0
+
+    total_output = sum(s["output_tokens"] for s in sessions)
+    total_input  = sum(s["input_tokens"] for s in sessions)
+
+    prompt_words = Counter()
+    for p in all_prompts:
+        for word in re.findall(r'\b[a-z]{4,}\b', p.lower()):
+            if word not in {"this", "that", "with", "from", "have", "will", "just", "your",
+                            "what", "when", "then", "also", "some", "into", "make", "more",
+                            "here", "they", "them", "been", "were", "need", "want", "code",
+                            "file", "like", "very", "only", "about", "would", "should",
+                            "could", "there", "their", "these", "those", "such", "both"}:
+                prompt_words[word] += 1
+
+    top_word = prompt_words.most_common(1)[0] if prompt_words else ("", 0)
+
+    polite = sum(1 for p in all_prompts if re.search(r'\b(please|thank|thanks|sorry)\b', p.lower()))
+    just_count = sum(p.lower().count("just") for p in all_prompts)
+    avg_len = int(sum(len(p) for p in all_prompts) / len(all_prompts)) if all_prompts else 0
+
+    untitled = sum(1 for s in sessions if not s["title"])
+
+    return {
+        "total_sessions": len(sessions),
+        "total_tool_calls": total_tool_calls,
+        "total_output_tokens": total_output,
+        "total_input_tokens": total_input,
+        "tool_pct": tool_pct,
+        "top_tools": total_tools.most_common(5),
+        "top_project": projects.most_common(1)[0] if projects else ("none", 0),
+        "project_count": len(projects),
+        "peak_hour": peak_hour,
+        "night_pct": night_pct,
+        "longest": longest,
+        "longest_mins": longest_mins,
+        "avg_prompt_len": avg_len,
+        "polite_count": polite,
+        "just_count": just_count,
+        "untitled_count": untitled,
+        "top_word": top_word,
+        "total_sessions_list": sessions,
+    }
+
+
+def fmt_hour(h: int) -> str:
+    if h == 0:   return "midnight"
+    if h < 12:   return f"{h}am"
+    if h == 12:  return "noon"
+    return f"{h - 12}pm"
+
+
+def fmt_tokens(n: int) -> str:
+    if n >= 1_000_000: return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:     return f"{n // 1_000}K"
+    return str(n)
+
+
+def fmt_duration(mins: int) -> str:
+    if mins < 60: return f"{mins}m"
+    h = mins // 60
+    m = mins % 60
+    return f"{h}h {m}m" if m else f"{h}h"
+
+
+ARCHETYPES = {
+    "THE ORCHESTRATOR": {
+        "color": MAGENTA,
+        "short": "Why do one thing when you can spawn five agents in parallel? You delegate like a CEO who just discovered hiring.",
+        "full": "You've internalized the most important insight in AI-native development: Claude is a fleet, not a tool. While others prompt one thing at a time, you parallelize. Your sessions look like org charts.",
+        "famous_for": "Spawning subagents to research while you're already writing the implementation",
+        "strength": "You get compound leverage out of Claude that most users never access.",
+        "watch_out": "Orchestration overhead can exceed the task cost. Sometimes one good prompt beats five parallel ones.",
+    },
+    "THE BASH HAMMER": {
+        "color": RED,
+        "short": "You don't read docs. You run things and see what breaks. The terminal is your native tongue.",
+        "full": "Your debugging strategy is empirical: run it, watch it fail, learn from the output. Documentation is for people who have time. You'd rather have stderr than a man page. The feedback loop between you and a running process is tighter than most engineers get in a full week.",
+        "famous_for": "Running a command to see if it works before asking why it might not",
+        "strength": "Speed. Nothing you ship has been theorized to death.",
+        "watch_out": "\"It worked on my machine\" is a philosophy, not a workaround.",
+    },
+    "THE DETECTIVE": {
+        "color": CYAN,
+        "short": "You investigate before you act. The codebase has no secrets from you. You find things first.",
+        "full": "You Grep before you guess. You Read before you rewrite. Your sessions start with an investigation phase that most developers skip entirely, which is why you break fewer things. The codebase isn't a mystery to you — it's a crime scene you've already mapped.",
+        "famous_for": "Knowing exactly where the bug is before touching a single file",
+        "strength": "Your changes are targeted. Your blast radius is minimal.",
+        "watch_out": "Sometimes you read so much the fix is obvious in your head but still not in the code.",
+    },
+    "THE FILE SURGEON": {
+        "color": GREEN,
+        "short": "Precise, deliberate, minimal blast radius. You fix what needs fixing and leave the rest alone.",
+        "full": "Your PRs are small and your diffs are clean. While others rewrite files to fix a function, you cut with precision. Edit + Write dominate your sessions because you're not exploring — you already know what needs to change. You operate like a surgeon: in, fix it, close.",
+        "famous_for": "The smallest diff that completely solves the problem",
+        "strength": "Clean git history. Low regression risk. Reviews that take 5 minutes.",
+        "watch_out": "Sometimes the right fix actually is a full rewrite. Precision can become avoidance.",
+    },
+    "THE NIGHT OWL": {
+        "color": BLUE,
+        "short": "Your best code ships after midnight. Sleep is optional. The dark hours are yours.",
+        "full": "You've found the only time slot with no meetings, no Slack pings, and no one asking for status updates. Late-night coding sessions have a different quality — longer, deeper, fewer interruptions. The commit timestamps tell the story. You're not burning out. You're just on a different schedule.",
+        "famous_for": "Pushing commits at 2am that somehow work in standup",
+        "strength": "Uninterrupted focus blocks that most developers can only dream about.",
+        "watch_out": "The merge conflicts waiting in the morning. And the sleep debt.",
+    },
+    "THE ESSAYIST": {
+        "color": YELLOW,
+        "short": "You explain everything. Context, edge cases, constraints, the history. Claude always knows exactly what you want.",
+        "full": "Your prompts read like engineering specs. You front-load context, enumerate constraints, and explain what you've already tried. The result is that Claude's first output hits close to correct more often than average. You've traded prompt time for iteration time, and it's a good trade.",
+        "famous_for": "3-paragraph prompts that get first-pass outputs most people take 5 attempts to reach",
+        "strength": "High hit rate on first output. Claude is never guessing with you.",
+        "watch_out": "Occasionally the prompt takes longer to write than the task would have taken to do manually.",
+    },
+    "THE COMMANDER": {
+        "color": RED,
+        "short": "Short, direct, no ceremony. \"Fix it.\" \"Add auth.\" \"Make it faster.\" Claude figures out the rest.",
+        "full": "You prompt like someone who's been doing this long enough to trust the model. You don't over-explain because you've learned that Claude fills in context reasonably well — and when it doesn't, one correction is faster than a paragraph of upfront specification. Your sessions move fast.",
+        "famous_for": "Two-word prompts that somehow produce exactly the right thing",
+        "strength": "Tight iteration loops. High sessions-per-hour. No wasted setup.",
+        "watch_out": "The context that lives only in your head sometimes doesn't make it into the output.",
+    },
+    "THE GENERALIST": {
+        "color": WHITE,
+        "short": "No single tool dominates. You read the problem and pick the right approach. That's rarer than it sounds.",
+        "full": "Your tool usage is balanced because your problems are varied. You're not locked into a pattern — you Grep when you need to investigate, Edit when you know what to change, run Bash when you need feedback. The diversity in your sessions reflects the diversity of what you actually build.",
+        "famous_for": "Knowing which tool to reach for before you open the file",
+        "strength": "You don't have a hammer, so nothing looks like a nail.",
+        "watch_out": "Balance can read as indecisiveness. Sometimes a bias toward one approach is a feature.",
+    },
+}
+
+
+def get_archetype(stats: dict) -> tuple[str, str, str]:
+    profile = get_archetype_profile(stats)
+    return (profile["name"], profile["color"], profile["short"])
+
+
+def get_archetype_profile(stats: dict) -> dict:
+    tp = stats["tool_pct"]
+    bash_pct   = tp.get("Bash", 0)
+    read_pct   = tp.get("Read", 0) + tp.get("Glob", 0) + tp.get("Grep", 0)
+    edit_pct   = tp.get("Edit", 0) + tp.get("Write", 0)
+    agent_pct  = tp.get("Agent", 0)
+    night_pct  = stats["night_pct"]
+    avg_len    = stats["avg_prompt_len"]
+
+    if agent_pct > 10:
+        name = "THE ORCHESTRATOR"
+    elif bash_pct > 55:
+        name = "THE BASH HAMMER"
+    elif read_pct > 50:
+        name = "THE DETECTIVE"
+    elif edit_pct > 40:
+        name = "THE FILE SURGEON"
+    elif night_pct > 35:
+        name = "THE NIGHT OWL"
+    elif avg_len > 600:
+        name = "THE ESSAYIST"
+    elif avg_len < 80:
+        name = "THE COMMANDER"
+    else:
+        name = "THE GENERALIST"
+
+    profile = dict(ARCHETYPES[name])
+    profile["name"] = name
+
+    # Build 3 supporting stats specific to this archetype
+    supporting = []
+    if name == "THE BASH HAMMER":
+        supporting = [
+            f"Bash: {bash_pct}% of all tool calls",
+            f"Sessions: {stats['total_sessions']:,} total",
+            f"Peak hour: {fmt_hour(stats['peak_hour'])}",
+        ]
+    elif name == "THE DETECTIVE":
+        supporting = [
+            f"Grep + Read + Glob: {read_pct}% of tool calls",
+            f"Projects explored: {stats['project_count']}",
+            f"Avg prompt length: {avg_len} chars",
+        ]
+    elif name == "THE FILE SURGEON":
+        supporting = [
+            f"Edit + Write: {edit_pct}% of tool calls",
+            f"Sessions: {stats['total_sessions']:,} total",
+            f"Tokens generated: {fmt_tokens(stats['total_output_tokens'])}",
+        ]
+    elif name == "THE ORCHESTRATOR":
+        supporting = [
+            f"Agent calls: {agent_pct}% of tool calls",
+            f"Total tool calls: {stats['total_tool_calls']:,}",
+            f"Projects active: {stats['project_count']}",
+        ]
+    elif name == "THE NIGHT OWL":
+        supporting = [
+            f"After-10pm sessions: {night_pct}%",
+            f"Peak hour: {fmt_hour(stats['peak_hour'])}",
+            f"Total sessions: {stats['total_sessions']:,}",
+        ]
+    elif name == "THE ESSAYIST":
+        supporting = [
+            f"Avg prompt: {avg_len} characters",
+            f"Sessions: {stats['total_sessions']:,}",
+            f"Top tool: {stats['top_tools'][0][0] if stats['top_tools'] else 'Bash'}",
+        ]
+    elif name == "THE COMMANDER":
+        supporting = [
+            f"Avg prompt: {avg_len} characters",
+            f"Sessions: {stats['total_sessions']:,}",
+            f"Peak hour: {fmt_hour(stats['peak_hour'])}",
+        ]
+    else:
+        t5 = stats["top_tools"][:3]
+        supporting = [f"{t}: {c} calls" for t, c in t5]
+
+    profile["supporting"] = supporting
+    return profile
+
+
+def get_secondary_trait(stats: dict) -> tuple[str, str] | None:
+    just = stats["just_count"]
+    polite = stats["polite_count"]
+    untitled = stats["untitled_count"]
+    total = stats["total_sessions"]
+
+    if just > 30:
+        return ("The Just-er", f"You said \"just\" {just} times. Just do it. Just fix it. Just make it work.")
+    if polite > 20:
+        return ("The Polite Prompter", f"You said please or thank you {polite} times. Claude appreciates it.")
+    if untitled > total * 0.5:
+        pct = round(100 * untitled / total)
+        return ("The Untitled", f"{pct}% of your sessions have no title. Living dangerously.")
+    if stats["night_pct"] > 25 and stats.get("tool_pct", {}).get("Bash", 0) > 40:
+        return ("The 2am Deployer", "You know what you're doing. You just don't know when to stop.")
+    return None
+
+
+def get_prompt_dna(stats: dict) -> dict:
+    avg_len   = stats["avg_prompt_len"]
+    just      = stats["just_count"]
+    polite    = stats["polite_count"]
+    total     = stats["total_sessions"]
+    tp        = stats["tool_pct"]
+    bash      = tp.get("Bash", 0)
+    night     = stats["night_pct"]
+    top_word  = stats["top_word"]
+
+    # Formality: polite → formal, terse → informal
+    if polite > total * 0.3:
+        formality = ("formal", "You treat Claude like a colleague. Please and thank you included.")
+    elif avg_len < 80:
+        formality = ("blunt", "No preamble. No ceremony. You get to the point faster than most people think.")
+    else:
+        formality = ("direct", "Professional but not stiff. You explain what you need without small talk.")
+
+    # Verbosity
+    if avg_len > 700:
+        verbosity = ("verbose", f"Avg {avg_len} chars per prompt. You front-load context, enumerate constraints, explain edge cases. Claude rarely has to ask a follow-up.")
+    elif avg_len > 300:
+        verbosity = ("moderate", f"Avg {avg_len} chars. Enough context to be useful, not so much that you're writing a spec instead of a prompt.")
+    elif avg_len > 100:
+        verbosity = ("terse", f"Avg {avg_len} chars. Short and functional. You've learned what Claude needs to get there.")
+    else:
+        verbosity = ("minimal", f"Avg {avg_len} chars. You prompt in fragments. \"Fix it.\" \"Add tests.\" Claude fills in the rest.")
+
+    # Command style
+    if bash > 55:
+        style = ("executor", "Your prompts are task orders. You want Claude to run something, not think about running something.")
+    elif just > 40:
+        style = ("minimizer", f"You say \"just\" a lot ({just}x). You minimize the ask in the prompt. It's a habit.")
+    elif avg_len > 600:
+        style = ("specifier", "You write prompts like requirements. Comprehensive. Claude gets it right because you leave nothing out.")
+    else:
+        style = ("collaborator", "You prompt back and forth. Claude is a thinking partner, not an executor.")
+
+    # Time pattern
+    if night > 35:
+        timing = ("nocturnal", "Most of your prompts land after 10pm. Your creative output happens in the dark.")
+    elif stats["peak_hour"] < 9:
+        timing = ("early riser", "You're at it before most people open Slack.")
+    elif stats["peak_hour"] > 17:
+        timing = ("after-hours", "Your peak is late afternoon into evening. You warm up slowly.")
+    else:
+        timing = ("office hours", f"Peak hour: {fmt_hour(stats['peak_hour'])}. You work when the world expects you to.")
+
+    # One-liner summary
+    summaries = {
+        ("formal", "verbose",   "specifier"):    "You prompt like a senior engineer writing an RFC. Thorough, polite, leaves nothing to interpretation.",
+        ("formal", "verbose",   "collaborator"):  "You prompt like a thoughtful manager delegating to a smart report. Context-first, measured tone.",
+        ("blunt",  "minimal",   "executor"):      "You prompt like a tired sysadmin at 2am. Fast, functional, zero ceremony. It works.",
+        ("blunt",  "terse",     "executor"):      "Short commands, high trust. You've calibrated Claude to your shorthand.",
+        ("direct", "moderate",  "collaborator"):  "Clear and efficient. You prompt like someone who respects both their time and Claude's ability.",
+        ("direct", "verbose",   "specifier"):     "You prompt like a product manager who's also a developer. Structured, specific, outcome-focused.",
+        ("direct", "terse",     "executor"):      "Functional and fast. You know what you want and you say it.",
+        ("direct", "moderate",  "executor"):      "You prompt like a developer who's done this before. Not terse, not long-winded. Just clear.",
+        ("direct", "verbose",   "executor"):      "You write long prompts that end in short commands. The context is the care; the task is the punch.",
+        ("direct", "terse",     "collaborator"):  "Efficient back-and-forth. Short prompts, quick corrections, good signal.",
+        ("blunt",  "verbose",   "executor"):      "Dense task orders. You write a lot but you're still clearly telling Claude what to do, not asking.",
+        ("blunt",  "moderate",  "executor"):      "You front-load just enough context to get the output right, then ship it. Clean loop.",
+        ("formal", "terse",     "specifier"):     "Polite but demanding. You know exactly what you want and you ask for it nicely.",
+        ("formal", "moderate",  "collaborator"):  "You work with Claude like a trusted colleague. Respectful, collaborative, clear.",
+    }
+
+    key = (formality[0], verbosity[0], style[0])
+    summary = summaries.get(key, f"You prompt {formality[0]}, {verbosity[0]}, and {style[0]}. That combination is distinctly yours.")
+
+    return {
+        "formality": formality,
+        "verbosity": verbosity,
+        "style": style,
+        "timing": timing,
+        "summary": summary,
+        "top_word": top_word,
+    }
+
+
+def print_dna(stats: dict, days: int, no_color: bool = False):
+    if no_color:
+        color_disabled()
+
+    dna = get_prompt_dna(stats)
+    archetype_name, arch_color, _ = get_archetype(stats)
+    W = 46
+
+    print()
+    print(f"  {BOLD}{MAGENTA}{'━' * W}{RESET}")
+    print(f"  {BOLD}{MAGENTA}  YOUR PROMPT STYLE DNA{RESET}")
+    print(f"  {DIM}  how you actually talk to Claude{RESET}")
+    print(f"  {BOLD}{MAGENTA}{'━' * W}{RESET}")
+    print()
+
+    traits = [
+        ("Formality",  dna["formality"][0].upper(),  dna["formality"][1],  CYAN),
+        ("Verbosity",  dna["verbosity"][0].upper(),  dna["verbosity"][1],  GREEN),
+        ("Style",      dna["style"][0].upper(),      dna["style"][1],      YELLOW),
+        ("Timing",     dna["timing"][0].upper(),      dna["timing"][1],     BLUE),
+    ]
+
+    for label, value, desc, color in traits:
+        print(f"  {BOLD}{color}{label}: {value}{RESET}")
+        for line in textwrap.wrap(desc, W - 2):
+            print(f"  {DIM}{line}{RESET}")
+        print()
+
+    print(f"  {DIM}{'─' * W}{RESET}")
+    print()
+    print(f"  {BOLD}The one-liner:{RESET}")
+    for line in textwrap.wrap(dna["summary"], W):
+        print(f"  {line}")
+    print()
+
+    if dna["top_word"][0]:
+        print(f"  {DIM}Most used word: \"{dna['top_word'][0]}\" ({dna['top_word'][1]}x){RESET}")
+        print()
+
+    print(f"  {DIM}Archetype: {arch_color}{BOLD}{archetype_name}{RESET}")
+    print()
+    print(f"  {BOLD}{MAGENTA}{'━' * W}{RESET}")
+    print()
+    print(f"  {DIM}Try it: github.com/turleydesigns/claude-wrapped{RESET}")
+    print(f"  {DIM}python3 wrapped.py --dna{RESET}")
+    print(f"  {DIM}What's your prompt style?{RESET}")
+    print()
+
+
+def generate_claude_md_block(stats: dict) -> list[tuple[str, str]]:
+    """Returns list of (rule, reason) tuples based on actual session patterns."""
+    tp       = stats["tool_pct"]
+    bash     = tp.get("Bash", 0)
+    read     = tp.get("Read", 0) + tp.get("Glob", 0) + tp.get("Grep", 0)
+    edit     = tp.get("Edit", 0) + tp.get("Write", 0)
+    agent    = tp.get("Agent", 0)
+    night    = stats["night_pct"]
+    peak_h   = stats["peak_hour"]
+    avg_len  = stats["avg_prompt_len"]
+    just     = stats["just_count"]
+    polite   = stats["polite_count"]
+    total    = stats["total_sessions"]
+    untitled = stats["untitled_count"]
+
+    rules = []
+
+    # Bash-first preference
+    if bash > 55:
+        rules.append((
+            f"When I ask you to run or check something, use Bash first. Don't suggest reading docs or alternative approaches unless I ask.",
+            f"You use Bash {bash}% of the time — this matches your actual workflow."
+        ))
+
+    # Don't ask clarifying questions upfront
+    if avg_len > 500:
+        rules.append((
+            "I provide full context in my prompts. Start working with what I give you. Don't ask clarifying questions before attempting the task.",
+            f"Your avg prompt is {avg_len} chars — you front-load context well."
+        ))
+
+    # Just = not simple
+    if just > 25:
+        rules.append((
+            "When I use the word 'just' in a prompt, ignore it as a signal of simplicity. The task is rarely as simple as that word implies.",
+            f"You said 'just' {just} times. It's a consistent pattern."
+        ))
+
+    # Minimal diffs
+    if edit > 40:
+        rules.append((
+            "Prefer targeted edits over full rewrites. Keep diffs minimal unless I explicitly ask for a rewrite.",
+            f"Edit + Write is {edit}% of your tool calls — you work surgically."
+        ))
+
+    # Read before touching
+    if read > 45:
+        rules.append((
+            "Before making changes to unfamiliar code, read the relevant files first. Don't assume structure from filenames.",
+            f"You use Read/Grep/Glob {read}% of the time — you investigate before acting."
+        ))
+
+    # Late night: no preamble
+    if night > 30:
+        rules.append((
+            "Keep responses direct and skip lengthy preambles. I often work late and don't need warmup text before the answer.",
+            f"{night}% of your sessions are after 10pm."
+        ))
+
+    # Early morning: same
+    if peak_h <= 7:
+        rules.append((
+            f"My peak hour is {fmt_hour(peak_h)}. Get straight to the work. Skip introductory context I already know.",
+            "Early sessions suggest you prefer efficiency over explanation."
+        ))
+
+    # Subagents
+    if agent > 8:
+        rules.append((
+            "When a task can be parallelized, suggest spawning subagents rather than doing things sequentially.",
+            f"You use Agent calls {agent}% of the time — you think in parallel."
+        ))
+
+    # Formal register
+    if polite > total * 0.2:
+        rules.append((
+            "Match my communication register. I'm direct but professional. Skip informal phrases.",
+            f"You use polite language in {polite} sessions — you communicate formally."
+        ))
+
+    # Short prompts: need more inference
+    if avg_len < 80:
+        rules.append((
+            "My prompts are often short. Use context from recent conversation history to fill in what I haven't explicitly stated.",
+            f"Avg prompt is {avg_len} chars — you trust Claude to infer context."
+        ))
+
+    # High untitled — suggest titling behavior
+    if untitled > total * 0.6:
+        pct = round(100 * untitled / total)
+        rules.append((
+            "If we've done something worth remembering, suggest a session title at the end.",
+            f"{pct}% of your sessions are untitled."
+        ))
+
+    return rules
+
+
+def get_spirit_model(stats: dict) -> tuple[str, str, str, list[str]]:
+    tp = stats["tool_pct"]
+    bash_pct = tp.get("Bash", 0)
+    read_pct = tp.get("Read", 0) + tp.get("Glob", 0) + tp.get("Grep", 0)
+    avg_len  = stats["avg_prompt_len"]
+
+    is_opus = avg_len > 500 or read_pct > 40
+    is_haiku = avg_len < 120 or (bash_pct > 60 and stats["untitled_count"] > stats["total_sessions"] * 0.5)
+
+    if is_opus and not is_haiku:
+        name = "Claude Opus"
+        color = MAGENTA
+        tagline = "Methodical, first-principles, thorough."
+        quip    = "You could write a thesis before writing the code."
+        data    = [
+            f"Avg prompt: {avg_len} chars",
+            f"Read/Grep/Glob: {read_pct}% of tool calls",
+        ]
+    elif is_haiku and not is_opus:
+        name = "Claude Haiku"
+        color = CYAN
+        tagline = "Fast, minimal, no ceremony."
+        quip    = "You prompt like you're billed by the token."
+        data    = [
+            f"Avg prompt: {avg_len} chars",
+            f"Bash: {bash_pct}% of tool calls",
+        ]
+    else:
+        name = "Claude Sonnet"
+        color = GREEN
+        tagline = "Balanced, pragmatic, gets it done."
+        quip    = "You've found the balance and you know it."
+        data    = [
+            f"Avg prompt: {avg_len} chars",
+            f"Top tool: {stats['top_tools'][0][0] if stats['top_tools'] else 'Bash'}",
+        ]
+
+    return (name, color, f"{tagline}\n{quip}", data)
+
+
+def print_spirit(stats: dict, days: int, no_color: bool = False):
+    if no_color:
+        color_disabled()
+
+    name, color, description, data = get_spirit_model(stats)
+    lines = description.split("\n")
+    tagline = lines[0]
+    quip    = lines[1] if len(lines) > 1 else ""
+    W = 46
+
+    print()
+    print(f"  {BOLD}{'━' * W}{RESET}")
+    print(f"  {BOLD}  YOUR SPIRIT MODEL{RESET}")
+    print(f"  {BOLD}{'━' * W}{RESET}")
+    print()
+    name_pad = (W - len(name)) // 2
+    print(f"  {' ' * name_pad}{BOLD}{color}{name}{RESET}")
+    print()
+    print(f"  {tagline}")
+    print(f"  {DIM}{quip}{RESET}")
+    print()
+    for item in data:
+        print(f"  {BOLD}·{RESET} {item}")
+    print()
+    print(f"  {BOLD}{'━' * W}{RESET}")
+    print(f"  {DIM}python3 wrapped.py --spirit{RESET}")
+    print(f"  {DIM}What's your spirit model?{RESET}")
+    print()
+
+
+def print_tune_up(stats: dict, days: int, no_color: bool = False, write: bool = False, target_path: str | None = None):
+    if no_color:
+        color_disabled()
+
+    rules = generate_claude_md_block(stats)
+    W = 46
+
+    print()
+    print(f"  {BOLD}{GREEN}{'━' * W}{RESET}")
+    print(f"  {BOLD}{GREEN}  CLAUDE.md TUNE-UP{RESET}")
+    print(f"  {DIM}  based on {days} days of your actual sessions{RESET}")
+    print(f"  {BOLD}{GREEN}{'━' * W}{RESET}")
+    print()
+
+    # Find existing CLAUDE.md
+    cwd_claude = Path.cwd() / "CLAUDE.md"
+    home_claude = Path.home() / "CLAUDE.md"
+    found_path = None
+    if cwd_claude.exists():
+        found_path = cwd_claude
+    elif home_claude.exists():
+        found_path = home_claude
+
+    if found_path:
+        print(f"  {DIM}Found: {found_path}{RESET}")
+    else:
+        print(f"  {DIM}No CLAUDE.md found in current directory or home.{RESET}")
+    print()
+
+    if not rules:
+        print(f"  {DIM}No strong patterns detected yet. Try running after 7+ active days.{RESET}")
+        print()
+        return
+
+    print(f"  {BOLD}{len(rules)} suggestions based on your patterns:{RESET}")
+    print()
+
+    # Show proposed block
+    block_lines = ["## How I work (from session patterns)\n"]
+    for rule, reason in rules:
+        block_lines.append(f"- {rule}")
+
+    for i, (rule, reason) in enumerate(rules):
+        print(f"  {BOLD}{GREEN}{i+1}.{RESET} {DIM}{reason}{RESET}")
+        for line in textwrap.wrap(rule, W - 4):
+            print(f"     {line}")
+        print()
+
+    print(f"  {DIM}{'─' * W}{RESET}")
+    print()
+    print(f"  {BOLD}Proposed CLAUDE.md block:{RESET}")
+    print()
+    print(f"  {DIM}┌{'─' * (W - 2)}┐{RESET}")
+    for line in block_lines:
+        wrapped = textwrap.wrap(line, W - 6) if line.strip() else [""]
+        for wl in wrapped:
+            pad = W - 4 - len(wl)
+            print(f"  {DIM}│{RESET} {wl}{' ' * pad}{DIM}│{RESET}")
+    print(f"  {DIM}└{'─' * (W - 2)}┘{RESET}")
+    print()
+
+    if write:
+        dest = Path(target_path) if target_path else (found_path or cwd_claude)
+        existing = dest.read_text() if dest.exists() else ""
+        marker = "\n## How I work (from session patterns)\n"
+        if marker.strip() in existing:
+            print(f"  {YELLOW}CLAUDE.md already has a session-patterns block. Skipping write.{RESET}")
+        else:
+            with open(dest, "a") as f:
+                f.write("\n" + "\n".join(block_lines) + "\n")
+            print(f"  {BOLD}{GREEN}Written to {dest}{RESET}")
+    else:
+        print(f"  {DIM}To write this to CLAUDE.md:{RESET}")
+        print(f"  {DIM}  python3 wrapped.py --tune-up --write{RESET}")
+
+    print()
+    print(f"  {BOLD}{GREEN}{'━' * W}{RESET}")
+    print()
+    print(f"  {DIM}Try it: github.com/turleydesigns/claude-wrapped{RESET}")
+    print(f"  {DIM}python3 wrapped.py --tune-up{RESET}")
+    print()
+
+
+def build_roast(stats: dict, days: int) -> list[str]:
+    lines = []
+    total   = stats["total_sessions"]
+    tp      = stats["tool_pct"]
+    bash    = tp.get("Bash", 0)
+    grep    = tp.get("Grep", 0)
+    read    = tp.get("Read", 0)
+    edit    = tp.get("Edit", 0)
+    write   = tp.get("Write", 0)
+    agent   = tp.get("Agent", 0)
+    night   = stats["night_pct"]
+    peak_h  = stats["peak_hour"]
+    avg_len = stats["avg_prompt_len"]
+    just    = stats["just_count"]
+    polite  = stats["polite_count"]
+    untitled = stats["untitled_count"]
+    out_tok = stats["total_output_tokens"]
+    proj_ct = stats["project_count"]
+    longest = stats["longest_mins"]
+    top_word = stats["top_word"]
+
+    # Roast 1 — sessions volume
+    if total > 10000:
+        lines.append(f"You opened {total:,} Claude sessions in {days} days. At some point that stops being productivity and starts being a coping mechanism.")
+    elif total > 1000:
+        lines.append(f"{total:,} sessions in {days} days. Claude is basically your main relationship at this point.")
+    elif total > 100:
+        lines.append(f"{total} sessions in {days} days. Healthy. Worrying about you less now.")
+    else:
+        lines.append(f"Only {total} sessions in {days} days. Either you have a very healthy work-life balance or Claude kept crashing.")
+
+    # Roast 2 — Bash hammer
+    if bash > 60:
+        lines.append(f"Bash is {bash}% of your tool calls. You are not using Claude to help you think. You are using Claude to hold your terminal history.")
+    elif bash > 45:
+        lines.append(f"You run Bash {bash}% of the time. The docs exist. They are right there.")
+
+    # Roast 3 — Agent
+    if agent > 15:
+        lines.append(f"You spawn subagents {agent}% of the time. That's not workflow optimization, that's just hiring Claude to manage Claude.")
+    elif agent > 5:
+        lines.append(f"You've discovered subagents. Give it two weeks.")
+
+    # Roast 4 — read-heavy but doesn't act
+    if grep + read > 50 and edit + write < 15:
+        lines.append(f"You spend {grep + read}% of your time reading the codebase and {edit + write}% changing it. At some point reading becomes procrastinating.")
+
+    # Roast 5 — night owl
+    if night > 40:
+        lines.append(f"{night}% of your sessions started after 10pm. You have found a way to be consistently online during the hours when judgment is lowest. This is fine.")
+    elif night > 25:
+        lines.append(f"{night}% night sessions. Peak hour was {fmt_hour(peak_h)}. You're not a night owl, you're just avoiding something.")
+
+    # Roast 6 — prompt length extremes
+    if avg_len > 800:
+        lines.append(f"Your average prompt is {avg_len} characters. You write more context for Claude than you do for your teammates. This is probably correct.")
+    elif avg_len < 60:
+        lines.append(f"Average prompt length: {avg_len} characters. \"fix it\" is a complete sentence to you. Claude is doing a lot of inference work on your behalf.")
+
+    # Roast 7 — just count
+    if just > 50:
+        lines.append(f"You said \"just\" {just} times. Just fix it. Just add auth. Just make it work. The word \"just\" implies simplicity. Nothing you're asking Claude to do is simple.")
+    elif just > 20:
+        lines.append(f"You said \"just\" {just} times. It's a tell. You say it when you know the task is bigger than you're admitting.")
+
+    # Roast 8 — polite
+    if polite > 30:
+        lines.append(f"You said please or thank you {polite} times. Claude is not going to remember this. But it says something about you.")
+    elif polite == 0 and total > 50:
+        lines.append("You've never once said please or thank you to Claude. Not once. That's a choice.")
+
+    # Roast 9 — untitled sessions
+    if untitled > total * 0.7:
+        pct = round(100 * untitled / total)
+        lines.append(f"{pct}% of your sessions have no title. You are living in a sea of \"New Session\" and \"New Session (2)\" and you have made peace with this.")
+    elif untitled > 20:
+        lines.append(f"{untitled} sessions with no title. Future you is going to hate current you for this.")
+
+    # Roast 10 — tokens
+    books = round(out_tok / 5 / 90_000, 1)
+    if books > 100:
+        lines.append(f"Claude has generated {fmt_tokens(out_tok)} output tokens for you. That's {books}x the word count of Lord of the Rings. You've read all of it and remembered approximately none of it.")
+    elif books > 10:
+        lines.append(f"{fmt_tokens(out_tok)} output tokens. You've received more words from Claude than exist in most novels. Some of them were probably useful.")
+
+    # Roast 11 — project count
+    if proj_ct > 500:
+        lines.append(f"You have {proj_ct} active projects. That's not a portfolio. That's avoidance with version control.")
+    elif proj_ct > 50:
+        lines.append(f"{proj_ct} different projects in {days} days. You start things.")
+
+    # Roast 12 — longest session
+    if longest >= 480:
+        lines.append(f"Your longest session hit the 8-hour cap on our tracker. We stopped counting. You didn't stop working.")
+    elif longest > 120:
+        lines.append(f"Your longest session was {fmt_duration(longest)}. You got into it.")
+
+    # Roast 13 — top word
+    if top_word[0] and top_word[1] > 20:
+        lines.append(f"Your most common word in prompts was \"{top_word[0]}\" at {top_word[1]} times. This is either your main domain or your main problem.")
+
+    # Closer
+    lines.append(f"None of this is criticism. {total:,} sessions in {days} days means you're actually using the tool. That puts you ahead of most people who installed it and forgot about it.")
+
+    return lines
+
+
+def print_roast(stats: dict, days: int, no_color: bool = False):
+    if no_color:
+        color_disabled()
+
+    lines = build_roast(stats, days)
+    W = 46
+    archetype_name, arch_color, _ = get_archetype(stats)
+
+    print()
+    print(f"  {BOLD}{YELLOW}{'━' * W}{RESET}")
+    print(f"  {BOLD}{YELLOW}  THE ROAST{RESET}")
+    print(f"  {DIM}  {days}-day Claude Code session review{RESET}")
+    print(f"  {BOLD}{YELLOW}{'━' * W}{RESET}")
+    print()
+    print(f"  {DIM}Archetype: {arch_color}{BOLD}{archetype_name}{RESET}")
+    print()
+
+    for i, line in enumerate(lines):
+        # Wrap each roast item
+        wrapped = textwrap.wrap(line, W)
+        for wl in wrapped:
+            print(f"  {wl}")
+        print()
+
+    print(f"  {BOLD}{YELLOW}{'━' * W}{RESET}")
+    print()
+    print(f"  {DIM}Try it: github.com/turleydesigns/claude-wrapped{RESET}")
+    print(f"  {DIM}python3 wrapped.py --roast{RESET}")
+    print(f"  {DIM}What does yours say?{RESET}")
+    print()
+
+
+def print_archetype(stats: dict, days: int, no_color: bool = False):
+    if no_color:
+        color_disabled()
+
+    profile = get_archetype_profile(stats)
+    secondary = get_secondary_trait(stats)
+    W = 46
+
+    name  = profile["name"]
+    color = profile["color"]
+
+    print()
+    print(f"  {BOLD}{color}{'▓' * W}{RESET}")
+    print(f"  {BOLD}{color}{'▓':1}{'':^{W-2}}{'▓':1}{RESET}")
+    label = "YOUR CLAUDE CODE ARCHETYPE"
+    pad = (W - 2 - len(label)) // 2
+    print(f"  {BOLD}{color}▓{' ' * pad}{label}{' ' * (W - 2 - pad - len(label))}▓{RESET}")
+    print(f"  {BOLD}{color}{'▓':1}{'':^{W-2}}{'▓':1}{RESET}")
+    print(f"  {BOLD}{color}{'▓' * W}{RESET}")
+    print()
+
+    # Archetype name — big
+    name_pad = (W - len(name)) // 2
+    print(f"  {' ' * name_pad}{BOLD}{color}{name}{RESET}")
+    print()
+
+    # Full description
+    for line in textwrap.wrap(profile["full"], W):
+        print(f"  {line}")
+    print()
+
+    # 3 supporting stats
+    print(f"  {DIM}{'─' * W}{RESET}")
+    print()
+    for stat in profile["supporting"]:
+        print(f"  {BOLD}·{RESET} {stat}")
+    print()
+
+    # Famous for / strength / watch out
+    print(f"  {DIM}{'─' * W}{RESET}")
+    print()
+    print(f"  {BOLD}{color}Famous for:{RESET}")
+    for line in textwrap.wrap(profile["famous_for"], W - 4):
+        print(f"    {line}")
+    print()
+    print(f"  {BOLD}{GREEN}Strength:{RESET}")
+    for line in textwrap.wrap(profile["strength"], W - 4):
+        print(f"    {line}")
+    print()
+    print(f"  {BOLD}{YELLOW}Watch out:{RESET}")
+    for line in textwrap.wrap(profile["watch_out"], W - 4):
+        print(f"    {line}")
+    print()
+
+    # Secondary trait
+    if secondary:
+        print(f"  {DIM}{'─' * W}{RESET}")
+        print()
+        trait_name, trait_desc = secondary
+        print(f"  {BOLD}✦ Secondary: {trait_name}{RESET}")
+        for line in textwrap.wrap(trait_desc, W - 2):
+            print(f"  {line}")
+        print()
+
+    # Footer
+    print(f"  {DIM}{'─' * W}{RESET}")
+    print()
+    print(f"  {DIM}Try it: github.com/turleydesigns/claude-wrapped{RESET}")
+    print(f"  {DIM}python3 wrapped.py --archetype{RESET}")
+    print(f"  {DIM}What's yours?{RESET}")
+    print()
+
+
+def print_slide(emoji: str, headline: str, body: str, color: str = WHITE):
+    w = 46
+    print()
+    print(f"  {BOLD}{color}{emoji}  {headline}{RESET}")
+    print()
+    for line in textwrap.wrap(body, w):
+        print(f"  {line}")
+    print()
+
+
+def print_separator():
+    print(f"  {DIM}{'─' * 44}{RESET}")
+
+
+def print_wrapped(stats: dict, days: int, no_color: bool = False):
+    if no_color:
+        color_disabled()
+
+    archetype_name, arch_color, arch_desc = get_archetype(stats)
+    secondary = get_secondary_trait(stats)
+
+    total_s   = stats["total_sessions"]
+    out_tok   = stats["total_output_tokens"]
+    in_tok    = stats["total_input_tokens"]
+    proj      = stats["top_project"][0]
+    proj_sess = stats["top_project"][1]
+    peak_h    = stats["peak_hour"]
+    night_pct = stats["night_pct"]
+    longest   = stats["longest"]
+    top_tool  = stats["top_tools"][0] if stats["top_tools"] else ("Bash", 0)
+    top_word  = stats["top_word"]
+    proj_ct   = stats["project_count"]
+
+    # output tokens / 5 ≈ words; avg book ~90k words
+    books = round(out_tok / 5 / 90_000, 1)
+    # rough estimate: avg session with >5 messages ≈ 12 min active
+    hours_est = round(total_s * 12 / 60)
+
+    # Header
+    print()
+    print(f"  {BOLD}{CYAN}{'━' * 44}{RESET}")
+    print(f"  {BOLD}{CYAN}  YOUR CLAUDE CODE WRAPPED{RESET}")
+    period = f"last {days} days"
+    print(f"  {DIM}  {period}{RESET}")
+    print(f"  {BOLD}{CYAN}{'━' * 44}{RESET}")
+
+    # Slide 1 — Big number
+    sessions_label = "sessions" if total_s != 1 else "session"
+    print_slide("🔥", "YOUR BIGGEST NUMBER", f"{BOLD}{total_s:,}{RESET} {sessions_label} with Claude in the last {days} days.", YELLOW)
+
+    print_separator()
+
+    # Slide 2 — Top project
+    print_slide("📍", "WHERE YOU LIVED", f"Your most active project was {BOLD}{proj}{RESET} — {proj_sess} sessions across {proj_ct} total projects.", GREEN)
+
+    print_separator()
+
+    # Slide 3 — Top tool
+    tool_pct = stats["tool_pct"].get(top_tool[0], 0)
+    print_slide("⚡", "YOUR WEAPON OF CHOICE", f"{BOLD}{top_tool[0]}{RESET} — you reached for it {tool_pct}% of the time. {top_tool[1]:,} calls total.", YELLOW)
+
+    print_separator()
+
+    # Slide 4 — Tokens
+    print_slide("🧠", "TOKENS BURNED", f"Claude generated {BOLD}{fmt_tokens(out_tok)}{RESET} output tokens for you.", CYAN)
+    if books > 0.5:
+        print(f"  {DIM}That's {books}x the word count of Lord of the Rings.{RESET}")
+
+    print_separator()
+
+    # Slide 5 — Timing
+    if night_pct > 20:
+        print_slide("🌙", f"YOU'RE A NIGHT OWL", f"{night_pct}% of your sessions started after 10pm. Your peak hour was {fmt_hour(peak_h)}.", BLUE)
+    else:
+        print_slide("⏰", f"PEAK HOUR: {fmt_hour(peak_h).upper()}", f"That's when you hit your stride. Night sessions: {night_pct}% of the total.", BLUE)
+
+    print_separator()
+
+    # Slide 6 — Longest session
+    if longest:
+        date_str = ""
+        if longest["timestamps"]:
+            date_str = f" on {min(longest['timestamps']).strftime('%b %d')}"
+        proj_str = f" in {longest['project']}" if longest["project"] else ""
+        print_slide("⏱", "LONGEST GRIND", f"{BOLD}{fmt_duration(stats['longest_mins'])}{RESET}{date_str}{proj_str}.", MAGENTA)
+
+    print_separator()
+
+    # Slide 7 — Archetype
+    print_slide("🧬", "YOUR ARCHETYPE", f"{BOLD}{arch_color}{archetype_name}{RESET}", arch_color)
+    for line in textwrap.wrap(arch_desc.replace(BOLD, "").replace(RESET, ""), 44):
+        print(f"  {line}")
+    print()
+
+    # Secondary trait
+    if secondary:
+        print_separator()
+        trait_name, trait_desc = secondary
+        print_slide("✦", f"SECONDARY TRAIT: {trait_name.upper()}", trait_desc, DIM)
+
+    # Slide 8 — Top word
+    if top_word[0]:
+        print_separator()
+        print_slide("💬", "YOUR MOST USED WORD", f"You said \"{BOLD}{top_word[0]}{RESET}\" {top_word[1]} times in your prompts.", DIM)
+
+    # Footer
+    print(f"  {BOLD}{CYAN}{'━' * 44}{RESET}")
+    print()
+    print(f"  {DIM}Try it: github.com/turleydesigns/claude-wrapped{RESET}")
+    print(f"  {DIM}What does yours say?{RESET}")
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Claude Code Wrapped — Spotify Wrapped for your Claude sessions.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--days",      type=int, default=30, help="days to look back (default: 30)")
+    parser.add_argument("--no-color",  action="store_true",  help="disable ANSI colors")
+    parser.add_argument("--archetype", action="store_true",  help="your coder archetype card")
+    parser.add_argument("--roast",     action="store_true",  help="personalized roast from your session data")
+    parser.add_argument("--dna",       action="store_true",  help="your prompt style DNA")
+    parser.add_argument("--tune-up",   action="store_true",  help="generate CLAUDE.md suggestions from your patterns")
+    parser.add_argument("--write",     action="store_true",  help="write tune-up suggestions to CLAUDE.md (use with --tune-up)")
+    parser.add_argument("--spirit",    action="store_true",  help="your spirit model — which Claude are you based on how you prompt")
+    args = parser.parse_args()
+
+    sessions = load_sessions(args.days)
+
+    if not sessions:
+        print(f"No Claude Code sessions found in the last {args.days} days.")
+        print(f"Looking in: {CLAUDE_DIR}")
+        sys.exit(0)
+
+    stats = aggregate(sessions)
+
+    if args.archetype:
+        print_archetype(stats, args.days, no_color=args.no_color)
+    elif args.roast:
+        print_roast(stats, args.days, no_color=args.no_color)
+    elif args.dna:
+        print_dna(stats, args.days, no_color=args.no_color)
+    elif getattr(args, "tune_up", False):
+        print_tune_up(stats, args.days, no_color=args.no_color, write=args.write)
+    elif args.spirit:
+        print_spirit(stats, args.days, no_color=args.no_color)
+    else:
+        print_wrapped(stats, args.days, no_color=args.no_color)
+
+
+if __name__ == "__main__":
+    main()