ccwrap 0.1.0

package/dist/data/parser.js

@@ -0,0 +1,358 @@
+import { readFile } from "fs/promises";
+import { glob } from "glob";
+import { homedir } from "os";
+import { join } from "path";
+// Pricing per million tokens (from Anthropic pricing page)
+// Each model has: input, output, cache_write (25% premium), cache_read (90% discount)
+const PRICING = {
+    "claude-opus-4-6": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
+    "claude-sonnet-4-6": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    "claude-sonnet-4-5-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    "claude-sonnet-4-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    "claude-haiku-4-5-20251001": { input: 0.80, output: 4, cacheWrite: 1.00, cacheRead: 0.08 },
+    "claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    "claude-3-5-haiku-20241022": { input: 0.80, output: 4, cacheWrite: 1.00, cacheRead: 0.08 },
+};
+function estimateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+    const pricing = Object.entries(PRICING).find(([key]) => model.includes(key))?.[1]
+        ?? (model.includes("opus") ? PRICING["claude-opus-4-6"]
+            : model.includes("haiku") ? PRICING["claude-haiku-4-5-20251001"]
+                : PRICING["claude-sonnet-4-6"]);
+    return (inputTokens * pricing.input +
+        outputTokens * pricing.output +
+        cacheCreationTokens * pricing.cacheWrite +
+        cacheReadTokens * pricing.cacheRead) / 1_000_000;
+}
+async function findJSONLFiles() {
+    const claudeDir = join(homedir(), ".claude", "projects");
+    const configDir = process.env.CLAUDE_CONFIG_DIR
+        ? join(process.env.CLAUDE_CONFIG_DIR, "projects")
+        : null;
+    const dirs = [claudeDir, configDir].filter(Boolean);
+    const allFiles = [];
+    for (const dir of dirs) {
+        try {
+            const files = await glob("**/*.jsonl", { cwd: dir, absolute: true });
+            allFiles.push(...files);
+        }
+        catch {
+            // Directory doesn't exist, skip
+        }
+    }
+    return allFiles;
+}
+async function parseJSONLFile(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.type === "assistant" && parsed.message?.usage) {
+                entries.push(parsed);
+            }
+        }
+        catch {
+            // Skip invalid lines
+        }
+    }
+    return entries;
+}
+function extractProject(filePath) {
+    // Path format: ~/.claude/projects/{encoded-project-path}/{sessionId}.jsonl
+    const parts = filePath.split("/projects/");
+    if (parts.length < 2)
+        return "unknown";
+    const afterProjects = parts[1];
+    const segments = afterProjects.split("/");
+    const projectEncoded = segments[0] ?? "unknown";
+    // Decode: -home-user-myproject -> /home/user/myproject
+    return projectEncoded
+        .replace(/^-/, "/")
+        .replace(/-/g, "/");
+}
+export async function loadAndComputeStats(range, periodLabel) {
+    const files = await findJSONLFiles();
+    if (files.length === 0) {
+        throw new Error("No Claude Code usage data found. Make sure you have used Claude Code before.");
+    }
+    // Parse all files
+    const allEntries = [];
+    for (const file of files) {
+        const entries = await parseJSONLFile(file);
+        for (const entry of entries) {
+            allEntries.push({ ...entry, _file: file });
+        }
+    }
+    if (allEntries.length === 0) {
+        throw new Error("No usage data entries found in Claude Code logs.");
+    }
+    // Sort by timestamp
+    allEntries.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    // Filter by date range if provided
+    if (range) {
+        const sinceMs = range.since.getTime();
+        const untilMs = range.until.getTime();
+        const before = allEntries.length;
+        const filtered = allEntries.filter(e => {
+            const ts = new Date(e.timestamp).getTime();
+            return ts >= sinceMs && ts <= untilMs;
+        });
+        allEntries.length = 0;
+        allEntries.push(...filtered);
+        if (allEntries.length === 0) {
+            throw new Error(`No usage data found in the selected time period (${before} entries exist outside this range).`);
+        }
+    }
+    // Build session map
+    const sessionMap = new Map();
+    for (const entry of allEntries) {
+        const sid = entry.sessionId;
+        if (!sessionMap.has(sid))
+            sessionMap.set(sid, []);
+        sessionMap.get(sid).push(entry);
+    }
+    // Compute session stats
+    const sessions = [];
+    for (const [sessionId, entries] of sessionMap) {
+        const timestamps = entries.map(e => new Date(e.timestamp));
+        const startTime = new Date(Math.min(...timestamps.map(t => t.getTime())));
+        const endTime = new Date(Math.max(...timestamps.map(t => t.getTime())));
+        const models = [...new Set(entries.map(e => e.message?.model).filter(Boolean))];
+        let totalInput = 0, totalOutput = 0, totalCacheCreate = 0, totalCacheRead = 0, totalCost = 0;
+        for (const entry of entries) {
+            const u = entry.message?.usage;
+            if (u) {
+                totalInput += u.input_tokens ?? 0;
+                totalOutput += u.output_tokens ?? 0;
+                totalCacheCreate += u.cache_creation_input_tokens ?? 0;
+                totalCacheRead += u.cache_read_input_tokens ?? 0;
+            }
+            if (entry.costUSD) {
+                totalCost += entry.costUSD;
+            }
+            else if (entry.message?.model && u) {
+                totalCost += estimateCost(entry.message.model, u.input_tokens ?? 0, u.output_tokens ?? 0, u.cache_creation_input_tokens ?? 0, u.cache_read_input_tokens ?? 0);
+            }
+        }
+        sessions.push({
+            sessionId,
+            project: extractProject(entries[0]._file),
+            startTime,
+            endTime,
+            durationMinutes: (endTime.getTime() - startTime.getTime()) / 60_000,
+            messageCount: entries.length,
+            totalInputTokens: totalInput,
+            totalOutputTokens: totalOutput,
+            totalCacheCreationTokens: totalCacheCreate,
+            totalCacheReadTokens: totalCacheRead,
+            totalTokens: totalInput + totalOutput + totalCacheCreate + totalCacheRead,
+            models,
+            costUSD: totalCost,
+        });
+    }
+    // Hourly activity
+    const hourly = Array.from({ length: 24 }, (_, i) => ({
+        hour: i,
+        messageCount: 0,
+        tokenCount: 0,
+    }));
+    for (const entry of allEntries) {
+        const hour = new Date(entry.timestamp).getHours();
+        hourly[hour].messageCount++;
+        const u = entry.message?.usage;
+        if (u) {
+            hourly[hour].tokenCount += (u.input_tokens ?? 0) + (u.output_tokens ?? 0);
+        }
+    }
+    // Daily activity
+    const dailyMap = new Map();
+    const dailySessionSets = new Map();
+    for (const entry of allEntries) {
+        const date = new Date(entry.timestamp).toISOString().split("T")[0];
+        if (!dailyMap.has(date)) {
+            dailyMap.set(date, { date, messageCount: 0, tokenCount: 0, costUSD: 0, sessions: 0 });
+            dailySessionSets.set(date, new Set());
+        }
+        const day = dailyMap.get(date);
+        day.messageCount++;
+        const u = entry.message?.usage;
+        if (u) {
+            day.tokenCount += (u.input_tokens ?? 0) + (u.output_tokens ?? 0);
+        }
+        dailySessionSets.get(date).add(entry.sessionId);
+    }
+    for (const [date, sessionSet] of dailySessionSets) {
+        dailyMap.get(date).sessions = sessionSet.size;
+    }
+    const dailyActivity = [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+    // Model usage
+    const modelMap = new Map();
+    for (const entry of allEntries) {
+        const model = entry.message?.model ?? "unknown";
+        if (!modelMap.has(model))
+            modelMap.set(model, { tokens: 0, messages: 0, cost: 0 });
+        const m = modelMap.get(model);
+        m.messages++;
+        const u = entry.message?.usage;
+        if (u) {
+            m.tokens += (u.input_tokens ?? 0) + (u.output_tokens ?? 0);
+        }
+    }
+    const totalTokensAll = [...modelMap.values()].reduce((sum, m) => sum + m.tokens, 0);
+    const modelUsage = [...modelMap.entries()]
+        .map(([model, data]) => ({
+        model,
+        tokenCount: data.tokens,
+        messageCount: data.messages,
+        costUSD: data.cost,
+        percentage: totalTokensAll > 0 ? (data.tokens / totalTokensAll) * 100 : 0,
+    }))
+        .sort((a, b) => b.tokenCount - a.tokenCount);
+    // Totals
+    const totalTokens = sessions.reduce((s, sess) => s + sess.totalTokens, 0);
+    const totalInputTokens = sessions.reduce((s, sess) => s + sess.totalInputTokens, 0);
+    const totalOutputTokens = sessions.reduce((s, sess) => s + sess.totalOutputTokens, 0);
+    const totalCost = sessions.reduce((s, sess) => s + sess.costUSD, 0);
+    const totalMessages = allEntries.length;
+    // Dates
+    const firstActivity = new Date(allEntries[0].timestamp);
+    const lastActivity = new Date(allEntries[allEntries.length - 1].timestamp);
+    const uniqueDays = new Set(allEntries.map(e => new Date(e.timestamp).toISOString().split("T")[0]));
+    const totalDaysActive = uniqueDays.size;
+    // Peak stats
+    const busiestDay = dailyActivity.reduce((best, d) => d.tokenCount > best.tokenCount ? d : best);
+    const busiestHour = hourly.reduce((best, h) => h.tokenCount > best.tokenCount ? h : best).hour;
+    const longestSession = sessions.reduce((best, s) => s.durationMinutes > best.durationMinutes ? s : best);
+    // Project frequency
+    const projectCounts = new Map();
+    for (const sess of sessions) {
+        projectCounts.set(sess.project, (projectCounts.get(sess.project) ?? 0) + sess.totalTokens);
+    }
+    const mostActiveProject = [...projectCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
+    // Streak
+    const sortedDays = [...uniqueDays].sort();
+    let maxStreak = 1, currentStreak = 1;
+    for (let i = 1; i < sortedDays.length; i++) {
+        const prev = new Date(sortedDays[i - 1]);
+        const curr = new Date(sortedDays[i]);
+        const diffDays = (curr.getTime() - prev.getTime()) / 86_400_000;
+        if (diffDays === 1) {
+            currentStreak++;
+            maxStreak = Math.max(maxStreak, currentStreak);
+        }
+        else {
+            currentStreak = 1;
+        }
+    }
+    // Scores
+    const nightTokens = hourly.filter(h => h.hour >= 22 || h.hour < 5).reduce((s, h) => s + h.tokenCount, 0);
+    const nightOwlScore = totalTokensAll > 0 ? Math.round((nightTokens / totalTokensAll) * 100) : 0;
+    const weekendEntries = allEntries.filter(e => {
+        const day = new Date(e.timestamp).getDay();
+        return day === 0 || day === 6;
+    });
+    const weekendWarriorScore = allEntries.length > 0
+        ? Math.round((weekendEntries.length / allEntries.length) * 100)
+        : 0;
+    const favoriteModel = modelUsage[0]?.model ?? "unknown";
+    const totalSessionHours = sessions.reduce((s, sess) => s + sess.durationMinutes, 0) / 60;
+    const avgSessionMinutes = sessions.length > 0 ? sessions.reduce((s, sess) => s + sess.durationMinutes, 0) / sessions.length : 0;
+    // Archetype
+    const { archetype, archetypeDescription } = computeArchetype({
+        nightOwlScore,
+        weekendWarriorScore,
+        avgSessionMinutes,
+        totalSessions: sessions.length,
+        streakDays: maxStreak,
+        totalTokens,
+        favoriteModel,
+    });
+    return {
+        periodLabel: periodLabel ?? "Your all-time",
+        totalTokens,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCost,
+        totalSessions: sessions.length,
+        totalMessages,
+        totalDaysActive,
+        firstActivity,
+        lastActivity,
+        busiestDay,
+        busiestHour,
+        longestSession,
+        mostActiveProject,
+        hourlyActivity: hourly,
+        dailyActivity,
+        modelUsage,
+        tokensPerDay: totalDaysActive > 0 ? Math.round(totalTokens / totalDaysActive) : 0,
+        avgSessionMinutes: Math.round(avgSessionMinutes),
+        nightOwlScore,
+        weekendWarriorScore,
+        streakDays: maxStreak,
+        favoriteModel,
+        archetype,
+        archetypeDescription,
+        warAndPeaceEquivalent: Math.round((totalTokens / 580_000) * 100) / 100,
+        coffeeEquivalent: Math.round(totalCost / 5),
+        marathonEquivalent: Math.round((totalSessionHours / 4.5) * 100) / 100,
+        // Environmental estimates (rough but directionally correct)
+        // ~0.5 liters of water per 1M tokens for data center cooling
+        waterLiters: Math.round(totalTokens / 1_000_000 * 0.5 * 100) / 100,
+        // ~0.3g CO2 per 1K tokens (inference energy + grid mix)
+        co2Grams: Math.round(totalTokens / 1_000 * 0.3),
+        // ~0.001 kWh per 1K tokens
+        kwhUsed: Math.round(totalTokens / 1_000 * 0.001 * 100) / 100,
+    };
+}
+function computeArchetype(params) {
+    const { nightOwlScore, weekendWarriorScore, avgSessionMinutes, totalSessions, streakDays, totalTokens, favoriteModel } = params;
+    if (nightOwlScore > 50) {
+        return {
+            archetype: "The Night Owl Demon",
+            archetypeDescription: "You code when the world sleeps. Your commit history is a horror movie for morning people.",
+        };
+    }
+    if (weekendWarriorScore > 40) {
+        return {
+            archetype: "The Weekend Warrior",
+            archetypeDescription: "While others brunch, you prompt. Your weekends are just weekdays with better snacks.",
+        };
+    }
+    if (avgSessionMinutes > 120) {
+        return {
+            archetype: "The Marathon Runner",
+            archetypeDescription: "Your sessions are longer than most movies. Touch grass? You've never heard of her.",
+        };
+    }
+    if (streakDays > 14) {
+        return {
+            archetype: "The Streak Machine",
+            archetypeDescription: "Day after day after day. Your consistency is either impressive or concerning. We're not sure which.",
+        };
+    }
+    if (totalTokens > 10_000_000) {
+        return {
+            archetype: "The Token Whale",
+            archetypeDescription: "You consume tokens like a whale consumes krill. Anthropic's servers know you by name.",
+        };
+    }
+    if (favoriteModel.includes("opus")) {
+        return {
+            archetype: "The Connoisseur",
+            archetypeDescription: "Only the finest model for you. Opus or bust. You have expensive taste and zero regrets.",
+        };
+    }
+    if (totalSessions > 50) {
+        return {
+            archetype: "The Serial Prompter",
+            archetypeDescription: "So many sessions, so little time. You start conversations like others start sentences.",
+        };
+    }
+    return {
+        archetype: "The Pragmatist",
+        archetypeDescription: "Efficient, focused, balanced. You use AI like a precision tool. How boring. (Just kidding, we respect it.)",
+    };
+}

package/dist/data/types.d.ts

@@ -0,0 +1,109 @@
+export interface RawJSONLEntry {
+    type: "assistant" | "user" | "queue-operation" | "summary";
+    timestamp: string;
+    sessionId: string;
+    cwd?: string;
+    version?: string;
+    message?: {
+        model?: string;
+        role?: string;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+        content?: Array<{
+            type: string;
+            text?: string;
+            thinking?: string;
+        }>;
+    };
+    costUSD?: number;
+}
+export interface SessionStats {
+    sessionId: string;
+    project: string;
+    startTime: Date;
+    endTime: Date;
+    durationMinutes: number;
+    messageCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCacheCreationTokens: number;
+    totalCacheReadTokens: number;
+    totalTokens: number;
+    models: string[];
+    costUSD: number;
+}
+export interface HourlyActivity {
+    hour: number;
+    messageCount: number;
+    tokenCount: number;
+}
+export interface DailyActivity {
+    date: string;
+    messageCount: number;
+    tokenCount: number;
+    costUSD: number;
+    sessions: number;
+}
+export interface ModelUsage {
+    model: string;
+    tokenCount: number;
+    messageCount: number;
+    costUSD: number;
+    percentage: number;
+}
+export interface DateRange {
+    since: Date;
+    until: Date;
+}
+export interface WrappedStats {
+    periodLabel: string;
+    totalTokens: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    totalSessions: number;
+    totalMessages: number;
+    totalDaysActive: number;
+    firstActivity: Date;
+    lastActivity: Date;
+    busiestDay: DailyActivity;
+    busiestHour: number;
+    longestSession: SessionStats;
+    mostActiveProject: string;
+    hourlyActivity: HourlyActivity[];
+    dailyActivity: DailyActivity[];
+    modelUsage: ModelUsage[];
+    tokensPerDay: number;
+    avgSessionMinutes: number;
+    nightOwlScore: number;
+    weekendWarriorScore: number;
+    streakDays: number;
+    favoriteModel: string;
+    archetype: string;
+    archetypeDescription: string;
+    warAndPeaceEquivalent: number;
+    coffeeEquivalent: number;
+    marathonEquivalent: number;
+    waterLiters: number;
+    co2Grams: number;
+    kwhUsed: number;
+}
+export interface VideoProps {
+    stats: WrappedStats;
+    commentary: Commentary;
+    mode: "sassy" | "dark";
+}
+export interface Commentary {
+    tokensLine: string;
+    costLine: string;
+    modelLine: string;
+    busiestDayLine: string;
+    sessionLine: string;
+    peakHoursLine: string;
+    archetypeLine: string;
+    summaryLine: string;
+}

package/dist/data/types.js

@@ -0,0 +1 @@
+export {};

package/dist/render.d.ts

@@ -0,0 +1,2 @@
+import type { WrappedStats, Commentary } from "./data/types";
+export declare function renderVideo(stats: WrappedStats, commentary: Commentary, mode: "sassy" | "dark", outputPath: string): Promise<string>;

package/dist/render.js

@@ -0,0 +1,60 @@
+import { bundle } from "@remotion/bundler";
+import { renderMedia, selectComposition } from "@remotion/renderer";
+import { resolve, dirname } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+function findChromeBinary() {
+    const candidates = [
+        "/root/.cache/ms-playwright/chromium_headless_shell-1194/chrome-linux/headless_shell",
+        "/root/.cache/ms-playwright/chromium-1194/chrome-linux/chrome",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/chromium",
+        "/usr/bin/google-chrome",
+    ];
+    return candidates.find(p => existsSync(p));
+}
+export async function renderVideo(stats, commentary, mode, outputPath) {
+    const resolvedOutput = resolve(process.cwd(), outputPath);
+    // Resolve entry point - works from both src/ (dev) and dist/ (published)
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const tsEntry = resolve(thisDir, "video", "index.ts");
+    const jsEntry = resolve(thisDir, "video", "index.js");
+    const entryPoint = existsSync(tsEntry) ? tsEntry : jsEntry;
+    const bundleLocation = await bundle({
+        entryPoint,
+        webpackOverride: (config) => ({
+            ...config,
+            module: {
+                ...config.module,
+                rules: [
+                    ...(config.module?.rules ?? []),
+                    { test: /\.m?js$/, resolve: { fullySpecified: false } },
+                ],
+            },
+        }),
+    });
+    const browserExecutable = findChromeBinary();
+    const inputProps = { stats, commentary, mode };
+    const composition = await selectComposition({
+        serveUrl: bundleLocation,
+        id: "CCWrapped",
+        inputProps,
+        browserExecutable,
+    });
+    await renderMedia({
+        composition,
+        serveUrl: bundleLocation,
+        codec: "h264",
+        outputLocation: resolvedOutput,
+        inputProps,
+        browserExecutable,
+        chromiumOptions: {
+            enableMultiProcessOnLinux: true,
+        },
+        crf: 15,
+        pixelFormat: "yuv420p",
+        x264Preset: "slow",
+        imageFormat: "png",
+    });
+    return resolvedOutput;
+}

package/dist/video/Composition.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { VideoProps } from "../data/types";
+export declare const TOTAL_SLIDES = 9;
+export declare const FPS = 30;
+export declare const TOTAL_DURATION: number;
+export declare const WIDTH = 900;
+export declare const HEIGHT = 900;
+export declare const CCWrappedComposition: React.FC<VideoProps>;

package/dist/video/Composition.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from "remotion";
+import { IntroSlide } from "./slides/IntroSlide";
+import { TokensSlide } from "./slides/TokensSlide";
+import { CostSlide } from "./slides/CostSlide";
+import { ModelSlide } from "./slides/ModelSlide";
+import { BusiestDaySlide } from "./slides/BusiestDaySlide";
+import { SessionSlide } from "./slides/SessionSlide";
+import { PeakHoursSlide } from "./slides/PeakHoursSlide";
+import { ArchetypeSlide } from "./slides/ArchetypeSlide";
+import { SummarySlide } from "./slides/SummarySlide";
+// Timing (at 30fps)
+const FADE_IN = 15; // 0.5s fade in
+const READABLE = 180; // 6s fully visible
+const FADE_OUT = 15; // 0.5s fade out
+const SLIDE_CONTENT = FADE_IN + READABLE + FADE_OUT; // 5s total per slide
+const BLACK_PAUSE = 25; // ~0.83s black between slides
+const SLIDE_SLOT = SLIDE_CONTENT + BLACK_PAUSE; // full slot per slide
+export const TOTAL_SLIDES = 9;
+export const FPS = 30;
+// Last slide has no black pause after it
+export const TOTAL_DURATION = SLIDE_SLOT * TOTAL_SLIDES - BLACK_PAUSE;
+// 900x900: renders sharp, displays crisp at 300x300 (3x density)
+export const WIDTH = 900;
+export const HEIGHT = 900;
+const SlideWithTransition = ({ children, index }) => {
+    const frame = useCurrentFrame();
+    const fadeIn = interpolate(frame, [0, FADE_IN], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp",
+    });
+    const fadeOut = index < TOTAL_SLIDES - 1
+        ? interpolate(frame, [FADE_IN + READABLE, SLIDE_CONTENT], [1, 0], { extrapolateLeft: "clamp", extrapolateRight: "clamp" })
+        : 1; // last slide stays visible
+    return (_jsx(AbsoluteFill, { style: { opacity: fadeIn * fadeOut }, children: children }));
+};
+export const CCWrappedComposition = ({ stats, commentary, mode }) => {
+    const slides = [
+        _jsx(IntroSlide, { mode: mode, periodLabel: stats.periodLabel }),
+        _jsx(TokensSlide, { stats: stats, commentary: commentary.tokensLine, mode: mode }),
+        _jsx(CostSlide, { stats: stats, commentary: commentary.costLine, mode: mode }),
+        _jsx(ModelSlide, { stats: stats, commentary: commentary.modelLine, mode: mode }),
+        _jsx(BusiestDaySlide, { stats: stats, commentary: commentary.busiestDayLine, mode: mode }),
+        _jsx(SessionSlide, { stats: stats, commentary: commentary.sessionLine, mode: mode }),
+        _jsx(PeakHoursSlide, { stats: stats, commentary: commentary.peakHoursLine, mode: mode }),
+        _jsx(ArchetypeSlide, { stats: stats, commentary: commentary.archetypeLine, mode: mode }),
+        _jsx(SummarySlide, { stats: stats, commentary: commentary.summaryLine, mode: mode }),
+    ];
+    return (_jsx(AbsoluteFill, { style: { backgroundColor: mode === "dark" ? "#050505" : "#0a0a0f" }, children: slides.map((slide, i) => (_jsx(Sequence, { from: i * SLIDE_SLOT, durationInFrames: SLIDE_CONTENT, name: `Slide ${i + 1}`, children: _jsx(SlideWithTransition, { index: i, children: slide }) }, i))) }));
+};

package/dist/video/Root.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const RemotionRoot: React.FC;

package/dist/video/Root.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Composition } from "remotion";
+import { CCWrappedComposition, TOTAL_DURATION, FPS, WIDTH, HEIGHT } from "./Composition";
+// Default stats for preview mode
+const defaultProps = {
+    mode: "sassy",
+    commentary: {
+        tokensLine: "That's a LOT of tokens bestie. Your AI dependency is showing.",
+        costLine: "You could've bought something nice. Instead you bought robot words.",
+        modelLine: "Sonnet? Balanced choice. Perfectly mid in the best way.",
+        busiestDayLine: "Valentine's Day?! You spent it with Claude?! We need to talk.",
+        sessionLine: "8.5 hours straight. Your chiropractor sends their regards.",
+        peakHoursLine: "10pm peak hour. The demons come out at night and they want code reviews.",
+        archetypeLine: "Night Owl Demon. The bags under your eyes have their own zip code.",
+        summaryLine: "Outsourcing your thinking at scale. Honestly? Respect.",
+    },
+    stats: {
+        periodLabel: "Your month",
+        totalTokens: 42_690_000,
+        totalInputTokens: 35_000_000,
+        totalOutputTokens: 7_690_000,
+        totalCost: 247.83,
+        totalSessions: 156,
+        totalMessages: 3847,
+        totalDaysActive: 89,
+        firstActivity: new Date("2025-06-01"),
+        lastActivity: new Date("2026-03-15"),
+        busiestDay: { date: "2026-02-14", messageCount: 247, tokenCount: 2_400_000, costUSD: 18.50, sessions: 8 },
+        busiestHour: 22,
+        longestSession: {
+            sessionId: "demo",
+            project: "/home/user/megaproject",
+            startTime: new Date("2026-02-14T14:00:00"),
+            endTime: new Date("2026-02-14T22:30:00"),
+            durationMinutes: 510,
+            messageCount: 247,
+            totalInputTokens: 2_000_000,
+            totalOutputTokens: 400_000,
+            totalCacheCreationTokens: 500_000,
+            totalCacheReadTokens: 300_000,
+            totalTokens: 3_200_000,
+            models: ["claude-sonnet-4-6"],
+            costUSD: 18.50,
+        },
+        mostActiveProject: "/home/user/megaproject",
+        hourlyActivity: Array.from({ length: 24 }, (_, i) => ({
+            hour: i,
+            messageCount: Math.floor(Math.sin(i * 0.5) * 100 + 120 + (i >= 20 || i <= 2 ? 150 : 0)),
+            tokenCount: Math.floor(Math.sin(i * 0.5) * 250000 + 300000 + (i >= 20 || i <= 2 ? 300000 : 0)),
+        })),
+        dailyActivity: Array.from({ length: 30 }, (_, i) => ({
+            date: `2026-02-${String(i + 1).padStart(2, "0")}`,
+            messageCount: Math.floor(Math.sin(i * 0.3) * 50 + 60),
+            tokenCount: Math.floor(Math.sin(i * 0.3) * 500000 + 600000),
+            costUSD: Math.sin(i * 0.3) * 10 + 12,
+            sessions: Math.floor(Math.sin(i * 0.3) * 2 + 3),
+        })),
+        modelUsage: [
+            { model: "claude-sonnet-4-6", tokenCount: 30_000_000, messageCount: 2500, costUSD: 150, percentage: 70 },
+            { model: "claude-opus-4-6", tokenCount: 10_000_000, messageCount: 800, costUSD: 80, percentage: 23 },
+            { model: "claude-haiku-4-5-20251001", tokenCount: 2_690_000, messageCount: 547, costUSD: 17, percentage: 7 },
+        ],
+        tokensPerDay: 479_663,
+        avgSessionMinutes: 45,
+        nightOwlScore: 68,
+        weekendWarriorScore: 23,
+        streakDays: 12,
+        favoriteModel: "claude-sonnet-4-6",
+        archetype: "The Night Owl Demon",
+        archetypeDescription: "You code when the world sleeps. Your commit history is a horror movie for morning people.",
+        warAndPeaceEquivalent: 73.6,
+        coffeeEquivalent: 50,
+        marathonEquivalent: 28.3,
+        waterLiters: 21.3,
+        co2Grams: 12807,
+        kwhUsed: 42.7,
+    },
+};
+export const RemotionRoot = () => {
+    return (_jsx(_Fragment, { children: _jsx(Composition, { id: "CCWrapped", component: CCWrappedComposition, durationInFrames: TOTAL_DURATION, fps: FPS, width: WIDTH, height: HEIGHT, defaultProps: defaultProps }) }));
+};