@sleekdesign/ccw25 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,970 @@
+/**
+ * Configuration for generating Claude Code Wrapped summary
+ */
+type ClaudeCodeWrappedConfig = {
+    /** Base directory for Claude data (default: ~/.claude) */
+    baseDir?: string;
+    /** Year to analyze (default: current year) */
+    year?: number;
+    /** Date range filter (overrides year if provided) */
+    dateRange?: {
+        from: Date;
+        to: Date;
+    };
+    /** Projects to include (default: all) */
+    projectFilter?: Array<string>;
+    /** Whether to use stats-cache.json for faster loading */
+    useStatsCache?: boolean;
+};
+/**
+ * Resolved configuration with all defaults applied
+ */
+type ResolvedConfig = {
+    baseDir: string;
+    year: number;
+    dateRange: {
+        from: Date;
+        to: Date;
+    };
+    projectFilter: Array<string> | null;
+    useStatsCache: boolean;
+};
+/**
+ * Result returned from wrapped summary generation
+ */
+type WrappedResult<T> = {
+    summary: T;
+    warnings: Array<WrappedWarning>;
+    errors: Array<WrappedError>;
+    stats: ProcessingStats;
+};
+type WrappedWarning = {
+    code: string;
+    message: string;
+    context?: Record<string, unknown>;
+};
+type WrappedError = {
+    code: string;
+    message: string;
+    fatal: boolean;
+};
+type ProcessingStats = {
+    filesProcessed: number;
+    filesSkipped: number;
+    entriesProcessed: number;
+    entriesSkipped: number;
+    processingTimeMs: number;
+};
+
+/**
+ * Computed metrics types for Claude Code Wrapped
+ * Organized into 7 tiers of insights
+ */
+/**
+ * Tier 1: Core Statistics
+ * Fundamental usage metrics
+ */
+type CoreMetrics = {
+    totalTokens: {
+        input: number;
+        output: number;
+        cacheCreation: number;
+        cacheRead: number;
+        total: number;
+    };
+    estimatedCost: {
+        total: number;
+        byCategory: {
+            input: number;
+            output: number;
+            cacheCreation: number;
+            cacheRead: number;
+        };
+    };
+    sessions: {
+        total: number;
+        averageMessages: number;
+        longestSession: {
+            id: string;
+            messageCount: number;
+            project: string;
+            date: Date;
+        } | null;
+    };
+    messages: {
+        total: number;
+        userMessages: number;
+        assistantMessages: number;
+        averagePerSession: number;
+    };
+    activity: {
+        daysActive: number;
+        totalDaysInPeriod: number;
+        longestStreak: number;
+        currentStreak: number;
+        firstActiveDay: Date | null;
+        lastActiveDay: Date | null;
+    };
+};
+/**
+ * Tier 2: Usage Patterns
+ * When and how you use Claude Code
+ */
+type PatternMetrics = {
+    peakHour: {
+        hour: number;
+        messageCount: number;
+    };
+    peakDayOfWeek: {
+        day: number;
+        dayName: string;
+        messageCount: number;
+    };
+    busiestMonth: {
+        month: number;
+        monthName: string;
+        messageCount: number;
+    };
+    hourlyDistribution: Array<{
+        hour: number;
+        count: number;
+    }>;
+    weeklyDistribution: Array<{
+        day: number;
+        dayName: string;
+        count: number;
+    }>;
+    monthlyDistribution: Array<{
+        month: number;
+        monthName: string;
+        count: number;
+    }>;
+};
+/**
+ * Tier 3: Model Usage
+ * Which AI models you prefer
+ */
+type ModelMetrics = {
+    modelsUsed: Array<{
+        model: string;
+        displayName: string;
+        messageCount: number;
+        tokenCount: number;
+        cost: number;
+        percentage: number;
+    }>;
+    favoriteModel: {
+        model: string;
+        displayName: string;
+        messageCount: number;
+        percentage: number;
+    } | null;
+    costByModel: Array<{
+        model: string;
+        displayName: string;
+        cost: number;
+        percentage: number;
+    }>;
+};
+/** Known Claude Code tool names */
+type ClaudeCodeTool = "Read" | "Edit" | "Write" | "Bash" | "Glob" | "Grep" | "Task" | "TodoRead" | "TodoWrite" | "WebFetch" | "WebSearch" | "AskUserQuestion" | "ExitPlanMode" | "EnterPlanMode" | "NotebookEdit" | "Skill" | "KillShell" | "TaskOutput" | string;
+/** Developer coding style profile */
+type DeveloperStyle = "reader" | "writer" | "executor" | "researcher" | "planner" | "balanced";
+/**
+ * Tier 4: Tool Usage (Developer DNA)
+ * Your coding assistant preferences
+ */
+type ToolMetrics = {
+    toolCallsTotal: number;
+    toolDistribution: Array<{
+        tool: ClaudeCodeTool;
+        count: number;
+        percentage: number;
+    }>;
+    topTools: Array<{
+        tool: ClaudeCodeTool;
+        count: number;
+        rank: number;
+    }>;
+    subagentUsage: {
+        taskToolCalls: number;
+        subagentTypes: Array<{
+            type: string;
+            count: number;
+        }>;
+    };
+    mcpTools: Array<{
+        server: string;
+        tool: string;
+        count: number;
+    }>;
+    developerProfile: {
+        primaryStyle: DeveloperStyle;
+        styleBreakdown: {
+            reading: number;
+            writing: number;
+            executing: number;
+            researching: number;
+            planning: number;
+        };
+        description: string;
+    };
+};
+/**
+ * Tier 5: Project Insights
+ * Where you've been coding
+ */
+type ProjectMetrics = {
+    projectsWorkedOn: number;
+    projects: Array<{
+        path: string;
+        displayName: string;
+        sessionCount: number;
+        messageCount: number;
+        tokenCount: number;
+        lastActive: Date;
+    }>;
+    topProject: {
+        path: string;
+        displayName: string;
+        sessionCount: number;
+        messageCount: number;
+        percentageOfTotal: number;
+    } | null;
+    gitBranches: {
+        total: number;
+        branches: Array<{
+            name: string;
+            projectPath: string;
+            messageCount: number;
+        }>;
+    };
+};
+/**
+ * Tier 6: AI Collaboration Style
+ * How you work with Claude
+ */
+type CollaborationMetrics = {
+    cacheEfficiency: {
+        cacheHitRate: number;
+        cacheCreationRate: number;
+        estimatedSavings: number;
+    };
+    extendedThinking: {
+        messagesWithThinking: number;
+        percentageOfTotal: number;
+    };
+    interactivity: {
+        questionsAsked: number;
+        plansCreated: number;
+        todoItemsCreated: number;
+    };
+    serviceTier: {
+        standardRequests: number;
+        priorityRequests: number;
+        priorityPercentage: number;
+    };
+};
+/**
+ * Tier 7: Fun Statistics
+ * Interesting tidbits about your usage
+ */
+type FunMetrics = {
+    charactersGenerated: number;
+    wordsGenerated: number;
+    equivalentPages: number;
+    summaryWordCloud: Array<{
+        word: string;
+        count: number;
+    }>;
+    longestResponse: {
+        characterCount: number;
+        date: Date;
+        sessionId: string;
+    } | null;
+    mostActiveDay: {
+        date: Date;
+        messageCount: number;
+        tokensUsed: number;
+    } | null;
+    milestones: Array<{
+        type: string;
+        date: Date;
+        description: string;
+    }>;
+    versions: Array<{
+        version: string;
+        messageCount: number;
+        firstSeen: Date;
+    }>;
+};
+/**
+ * Complete Claude Code Wrapped Summary
+ * Contains all 7 tiers of metrics
+ */
+type ClaudeCodeWrappedSummary = {
+    generatedAt: Date;
+    period: {
+        from: Date;
+        to: Date;
+        year: number;
+    };
+    core: CoreMetrics;
+    patterns: PatternMetrics;
+    models: ModelMetrics;
+    tools: ToolMetrics;
+    projects: ProjectMetrics;
+    collaboration: CollaborationMetrics;
+    fun: FunMetrics;
+};
+
+/**
+ * Types for Claude Code JSONL log entries
+ */
+/** Base fields present on all JSONL entries */
+type BaseJSONLEntry = {
+    timestamp: string;
+    sessionId: string;
+    uuid?: string;
+};
+/** Token usage structure from assistant messages */
+type TokenUsage = {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation?: {
+        ephemeral_5m_input_tokens?: number;
+        ephemeral_1h_input_tokens?: number;
+    };
+    service_tier?: "standard" | "priority";
+};
+/** Tool use content block */
+type ToolUseContent = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+/** Text content block */
+type TextContent = {
+    type: "text";
+    text: string;
+};
+/** Thinking content block */
+type ThinkingContent = {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+};
+/** Content block union */
+type ContentBlock = ToolUseContent | TextContent | ThinkingContent;
+/** User message entry */
+type UserMessageEntry = BaseJSONLEntry & {
+    type: "user";
+    message: {
+        role: "user";
+        content: string;
+    };
+    version?: string;
+    gitBranch?: string;
+    cwd?: string;
+    parentUuid?: string | null;
+    isSidechain?: boolean;
+    userType?: string;
+};
+/** Assistant message entry */
+type AssistantMessageEntry = BaseJSONLEntry & {
+    type: "assistant";
+    message: {
+        model: string;
+        id?: string;
+        type?: "message";
+        role: "assistant";
+        content: Array<ContentBlock>;
+        stop_reason?: string | null;
+        stop_sequence?: string | null;
+        usage: TokenUsage;
+    };
+    requestId?: string;
+    parentUuid?: string;
+    version?: string;
+    gitBranch?: string;
+    cwd?: string;
+    slug?: string;
+};
+/** Session summary entry */
+type SummaryEntry = BaseJSONLEntry & {
+    type: "summary";
+    summary: string;
+    leafUuid?: string;
+};
+/** File history snapshot entry */
+type FileHistoryEntry = BaseJSONLEntry & {
+    type: "file-history-snapshot";
+    messageId?: string;
+    snapshot?: {
+        messageId: string;
+        trackedFileBackups: Record<string, unknown>;
+        timestamp: string;
+    };
+    isSnapshotUpdate?: boolean;
+};
+/** Union of all JSONL entry types */
+type JSONLEntry = UserMessageEntry | AssistantMessageEntry | SummaryEntry | FileHistoryEntry;
+/** Stats cache daily activity entry */
+type StatsCacheDailyActivity = {
+    date: string;
+    messageCount: number;
+    sessionCount: number;
+    toolCallCount: number;
+};
+/** Stats cache structure */
+type StatsCache = {
+    version: number;
+    lastComputedDate: string;
+    dailyActivity: Array<StatsCacheDailyActivity>;
+};
+/** Session data with parsed entries */
+type SessionData = {
+    sessionId: string;
+    projectPath: string;
+    filePath: string;
+    entries: Array<JSONLEntry>;
+};
+
+/**
+ * Async iterator for Claude Code sessions
+ */
+
+/**
+ * Options for session iteration
+ */
+type SessionIteratorOptions = {
+    baseDir?: string;
+    dateRange?: {
+        from: Date;
+        to: Date;
+    };
+    projectFilter?: Array<string> | null;
+};
+/**
+ * Session metadata without entries (for lightweight enumeration)
+ */
+type SessionMetadata = {
+    sessionId: string;
+    projectPath: string;
+    projectDisplayName: string;
+    filePath: string;
+};
+/**
+ * Enumerate all sessions without loading content
+ */
+declare function enumerateSessions(options?: SessionIteratorOptions): Array<SessionMetadata>;
+/**
+ * Load a single session's entries
+ */
+declare function loadSession(metadata: SessionMetadata): Promise<SessionData>;
+/**
+ * Async generator that yields sessions with their entries
+ */
+declare function iterateSessions(options?: SessionIteratorOptions): AsyncGenerator<SessionData>;
+/**
+ * Load all sessions at once (convenience function)
+ */
+declare function loadAllSessions(options?: SessionIteratorOptions): Promise<Array<SessionData>>;
+/**
+ * Collect all entries from all sessions
+ */
+declare function collectAllEntries(options?: SessionIteratorOptions): Promise<{
+    entries: Array<JSONLEntry & {
+        sessionId: string;
+        projectPath: string;
+    }>;
+    sessionCount: number;
+}>;
+
+/**
+ * JSONL stream parser for Claude Code session files
+ */
+
+/**
+ * Parse result for a single line
+ */
+type ParseResult = {
+    success: true;
+    entry: JSONLEntry;
+} | {
+    success: false;
+    error: string;
+    line: number;
+};
+/**
+ * Parse a single JSONL line
+ */
+declare function parseLine(line: string, lineNumber: number): ParseResult;
+/**
+ * Parsing statistics
+ */
+type ParseStats = {
+    totalLines: number;
+    successfulLines: number;
+    failedLines: number;
+    errors: Array<{
+        line: number;
+        error: string;
+    }>;
+};
+/**
+ * Parse a JSONL file and yield entries
+ */
+declare function parseJSONLFile(filePath: string): AsyncGenerator<JSONLEntry, ParseStats>;
+/**
+ * Parse a JSONL file and return all entries at once
+ */
+declare function parseJSONLFileAll(filePath: string): Promise<{
+    entries: Array<JSONLEntry>;
+    stats: ParseStats;
+}>;
+
+/**
+ * Claude data directory detection and path utilities
+ */
+/**
+ * Detected Claude paths
+ */
+type ClaudePaths = {
+    baseDir: string;
+    projectsDir: string;
+    historyFile: string;
+    statsCacheFile: string;
+    exists: boolean;
+};
+/**
+ * Detect Claude data directory
+ * Checks CLAUDE_CONFIG_DIR env var first, then falls back to ~/.claude
+ */
+declare function detectClaudeDir(): string;
+/**
+ * Get all Claude paths
+ */
+declare function getClaudePaths(baseDir?: string): ClaudePaths;
+/**
+ * Project directory info
+ */
+type ProjectInfo = {
+    path: string;
+    displayName: string;
+    dirName: string;
+    sessionFiles: Array<string>;
+};
+/**
+ * Parse project name from directory path
+ * Converts encoded path like "-Users-stefanofa-Projects-reweb-sleek" to "sleek"
+ */
+declare function parseProjectName(dirName: string): string;
+/**
+ * Discover all project directories
+ */
+declare function discoverProjects(projectsDir: string): Array<ProjectInfo>;
+/**
+ * Discover all JSONL session files in a project directory
+ */
+declare function discoverSessionFiles(projectPath: string): Array<string>;
+/**
+ * Extract session ID from file path
+ */
+declare function extractSessionId(filePath: string): string;
+/**
+ * Extract project path from session file path
+ */
+declare function extractProjectPath(filePath: string): string;
+/**
+ * Get file modification time
+ */
+declare function getFileModTime(filePath: string): Date | null;
+/**
+ * Filter files by date range based on modification time
+ */
+declare function filterFilesByDate(files: Array<string>, from: Date, to: Date): Array<string>;
+
+/**
+ * Data loading for Claude Code Wrapped
+ */
+
+/**
+ * Loaded Claude data ready for analysis
+ */
+type LoadedData = {
+    sessions: Array<SessionData>;
+    entries: Array<JSONLEntry & {
+        sessionId: string;
+        projectPath: string;
+    }>;
+    statsCache: StatsCache | null;
+    config: ResolvedConfig;
+};
+/**
+ * Load all Claude data based on configuration
+ */
+declare function loadClaudeData(config: ResolvedConfig): Promise<LoadedData>;
+/**
+ * Resolve configuration with defaults
+ */
+declare function resolveConfig(config?: Partial<ResolvedConfig>): ResolvedConfig;
+
+type index$3_ClaudePaths = ClaudePaths;
+type index$3_LoadedData = LoadedData;
+type index$3_ParseResult = ParseResult;
+type index$3_ParseStats = ParseStats;
+type index$3_ProjectInfo = ProjectInfo;
+type index$3_SessionIteratorOptions = SessionIteratorOptions;
+type index$3_SessionMetadata = SessionMetadata;
+declare const index$3_collectAllEntries: typeof collectAllEntries;
+declare const index$3_detectClaudeDir: typeof detectClaudeDir;
+declare const index$3_discoverProjects: typeof discoverProjects;
+declare const index$3_discoverSessionFiles: typeof discoverSessionFiles;
+declare const index$3_enumerateSessions: typeof enumerateSessions;
+declare const index$3_extractProjectPath: typeof extractProjectPath;
+declare const index$3_extractSessionId: typeof extractSessionId;
+declare const index$3_filterFilesByDate: typeof filterFilesByDate;
+declare const index$3_getClaudePaths: typeof getClaudePaths;
+declare const index$3_getFileModTime: typeof getFileModTime;
+declare const index$3_iterateSessions: typeof iterateSessions;
+declare const index$3_loadAllSessions: typeof loadAllSessions;
+declare const index$3_loadClaudeData: typeof loadClaudeData;
+declare const index$3_loadSession: typeof loadSession;
+declare const index$3_parseJSONLFile: typeof parseJSONLFile;
+declare const index$3_parseJSONLFileAll: typeof parseJSONLFileAll;
+declare const index$3_parseLine: typeof parseLine;
+declare const index$3_parseProjectName: typeof parseProjectName;
+declare const index$3_resolveConfig: typeof resolveConfig;
+declare namespace index$3 {
+  export { type index$3_ClaudePaths as ClaudePaths, type index$3_LoadedData as LoadedData, type index$3_ParseResult as ParseResult, type index$3_ParseStats as ParseStats, type index$3_ProjectInfo as ProjectInfo, type index$3_SessionIteratorOptions as SessionIteratorOptions, type index$3_SessionMetadata as SessionMetadata, index$3_collectAllEntries as collectAllEntries, index$3_detectClaudeDir as detectClaudeDir, index$3_discoverProjects as discoverProjects, index$3_discoverSessionFiles as discoverSessionFiles, index$3_enumerateSessions as enumerateSessions, index$3_extractProjectPath as extractProjectPath, index$3_extractSessionId as extractSessionId, index$3_filterFilesByDate as filterFilesByDate, index$3_getClaudePaths as getClaudePaths, index$3_getFileModTime as getFileModTime, index$3_iterateSessions as iterateSessions, index$3_loadAllSessions as loadAllSessions, index$3_loadClaudeData as loadClaudeData, index$3_loadSession as loadSession, index$3_parseJSONLFile as parseJSONLFile, index$3_parseJSONLFileAll as parseJSONLFileAll, index$3_parseLine as parseLine, index$3_parseProjectName as parseProjectName, index$3_resolveConfig as resolveConfig };
+}
+
+/**
+ * Tier 6: AI Collaboration Style
+ * How you work with Claude
+ */
+
+/**
+ * Calculate collaboration metrics from entries
+ */
+declare function calculateCollaborationMetrics(entries: Array<JSONLEntry>): CollaborationMetrics;
+
+/**
+ * Claude model pricing data
+ * Prices are per 1 million tokens
+ */
+type ModelPricing = {
+    input: number;
+    output: number;
+    cacheWrite: number;
+    cacheRead: number;
+};
+/**
+ * Pricing data for known Claude models
+ * Updated as of December 2025
+ */
+declare const MODEL_PRICING: Record<string, ModelPricing>;
+/**
+ * Default pricing for unknown models (uses Sonnet pricing as reasonable middle)
+ */
+declare const DEFAULT_PRICING: ModelPricing;
+/**
+ * Get pricing for a model
+ */
+declare function getModelPricing(model: string): ModelPricing;
+/**
+ * Get display name for a model
+ */
+declare function getModelDisplayName(model: string): string;
+
+/**
+ * Cost calculation for Claude Code usage
+ */
+
+/**
+ * Cost breakdown by token type
+ */
+type CostBreakdown = {
+    input: number;
+    output: number;
+    cacheCreation: number;
+    cacheRead: number;
+    total: number;
+};
+/**
+ * Calculate cost for token usage
+ */
+declare function calculateCost(model: string, usage: TokenUsage): CostBreakdown;
+/**
+ * Calculate total tokens from usage
+ */
+declare function calculateTotalTokens(usage: TokenUsage): number;
+/**
+ * Aggregate costs from multiple usages
+ */
+declare function aggregateCosts(costs: Array<CostBreakdown>): CostBreakdown;
+/**
+ * Estimate cache savings (what you would have paid without cache)
+ */
+declare function estimateCacheSavings(model: string, cacheReadTokens: number): number;
+
+type index$2_CostBreakdown = CostBreakdown;
+declare const index$2_DEFAULT_PRICING: typeof DEFAULT_PRICING;
+declare const index$2_MODEL_PRICING: typeof MODEL_PRICING;
+type index$2_ModelPricing = ModelPricing;
+declare const index$2_aggregateCosts: typeof aggregateCosts;
+declare const index$2_calculateCost: typeof calculateCost;
+declare const index$2_calculateTotalTokens: typeof calculateTotalTokens;
+declare const index$2_estimateCacheSavings: typeof estimateCacheSavings;
+declare const index$2_getModelDisplayName: typeof getModelDisplayName;
+declare const index$2_getModelPricing: typeof getModelPricing;
+declare namespace index$2 {
+  export { type index$2_CostBreakdown as CostBreakdown, index$2_DEFAULT_PRICING as DEFAULT_PRICING, index$2_MODEL_PRICING as MODEL_PRICING, type index$2_ModelPricing as ModelPricing, index$2_aggregateCosts as aggregateCosts, index$2_calculateCost as calculateCost, index$2_calculateTotalTokens as calculateTotalTokens, index$2_estimateCacheSavings as estimateCacheSavings, index$2_getModelDisplayName as getModelDisplayName, index$2_getModelPricing as getModelPricing };
+}
+
+/**
+ * Tier 1: Core Statistics
+ * Fundamental usage metrics
+ */
+
+/**
+ * Calculate core metrics from entries
+ */
+declare function calculateCoreMetrics(entries: Array<JSONLEntry & {
+    sessionId: string;
+    projectPath: string;
+}>, dateRange: {
+    from: Date;
+    to: Date;
+}): CoreMetrics;
+
+/**
+ * Tier 7: Fun Statistics
+ * Interesting tidbits about your usage
+ */
+
+/**
+ * Calculate fun metrics from entries
+ */
+declare function calculateFunMetrics(entries: Array<JSONLEntry & {
+    sessionId: string;
+}>): FunMetrics;
+
+/**
+ * Tier 3: Model Usage
+ * Which AI models you prefer
+ */
+
+/**
+ * Calculate model metrics from entries
+ */
+declare function calculateModelMetrics(entries: Array<JSONLEntry>): ModelMetrics;
+
+/**
+ * Tier 2: Usage Patterns
+ * When and how you use Claude Code
+ */
+
+/**
+ * Calculate pattern metrics from entries
+ */
+declare function calculatePatternMetrics(entries: Array<JSONLEntry>): PatternMetrics;
+
+/**
+ * Tier 5: Project Insights
+ * Where you've been coding
+ */
+
+/**
+ * Calculate project metrics from entries
+ */
+declare function calculateProjectMetrics(entries: Array<JSONLEntry & {
+    sessionId: string;
+    projectPath: string;
+}>): ProjectMetrics;
+
+/**
+ * Tier 4: Tool Usage (Developer DNA)
+ * Your coding assistant preferences
+ */
+
+/**
+ * Calculate tool metrics from entries
+ */
+declare function calculateToolMetrics(entries: Array<JSONLEntry>): ToolMetrics;
+
+/**
+ * Metrics calculation for Claude Code Wrapped
+ */
+
+/**
+ * Calculate all metrics from entries
+ */
+declare function calculateAllMetrics(entries: Array<JSONLEntry & {
+    sessionId: string;
+    projectPath: string;
+}>, dateRange: {
+    from: Date;
+    to: Date;
+}): ClaudeCodeWrappedSummary;
+
+declare const index$1_calculateAllMetrics: typeof calculateAllMetrics;
+declare const index$1_calculateCollaborationMetrics: typeof calculateCollaborationMetrics;
+declare const index$1_calculateCoreMetrics: typeof calculateCoreMetrics;
+declare const index$1_calculateFunMetrics: typeof calculateFunMetrics;
+declare const index$1_calculateModelMetrics: typeof calculateModelMetrics;
+declare const index$1_calculatePatternMetrics: typeof calculatePatternMetrics;
+declare const index$1_calculateProjectMetrics: typeof calculateProjectMetrics;
+declare const index$1_calculateToolMetrics: typeof calculateToolMetrics;
+declare namespace index$1 {
+  export { index$1_calculateAllMetrics as calculateAllMetrics, index$1_calculateCollaborationMetrics as calculateCollaborationMetrics, index$1_calculateCoreMetrics as calculateCoreMetrics, index$1_calculateFunMetrics as calculateFunMetrics, index$1_calculateModelMetrics as calculateModelMetrics, index$1_calculatePatternMetrics as calculatePatternMetrics, index$1_calculateProjectMetrics as calculateProjectMetrics, index$1_calculateToolMetrics as calculateToolMetrics };
+}
+
+/**
+ * JSON export for Claude Code Wrapped
+ */
+
+/**
+ * Export metadata
+ */
+type ExportMetadata = {
+    version: string;
+    generatedAt: string;
+    generator: string;
+};
+/**
+ * Full export structure
+ */
+type WrappedExport = {
+    metadata: ExportMetadata;
+    summary: ClaudeCodeWrappedSummary;
+};
+/**
+ * Export summary as JSON
+ */
+declare function exportAsJSON(summary: ClaudeCodeWrappedSummary): string;
+/**
+ * Export summary as compact JSON (no formatting)
+ */
+declare function exportAsCompactJSON(summary: ClaudeCodeWrappedSummary): string;
+/**
+ * Export a single tier as JSON
+ */
+declare function exportTierAsJSON<K extends keyof ClaudeCodeWrappedSummary>(summary: ClaudeCodeWrappedSummary, tier: K): string;
+
+/**
+ * Wrapped-style text templates for display
+ */
+
+/**
+ * Wrapped text templates
+ */
+declare const templates: {
+    /**
+     * Main headline
+     */
+    headline: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Token statistics
+     */
+    tokenStats: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Cost summary
+     */
+    costSummary: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Favorite model
+     */
+    favoriteModel: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Developer profile
+     */
+    developerProfile: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Top tool
+     */
+    topTool: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Activity streak
+     */
+    activityStreak: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Peak hour
+     */
+    peakHour: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Busiest day
+     */
+    busiestDay: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Top project
+     */
+    topProject: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Cache efficiency
+     */
+    cacheEfficiency: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Words generated
+     */
+    wordsGenerated: (summary: ClaudeCodeWrappedSummary) => string;
+    /**
+     * Most active day
+     */
+    mostActiveDay: (summary: ClaudeCodeWrappedSummary) => string;
+};
+/**
+ * Generate a full wrapped summary text
+ */
+declare function generateWrappedText(summary: ClaudeCodeWrappedSummary): string;
+/**
+ * Generate a short summary (for sharing)
+ */
+declare function generateShortSummary(summary: ClaudeCodeWrappedSummary): string;
+
+/**
+ * Output formatting for Claude Code Wrapped
+ */
+
+type index_ExportMetadata = ExportMetadata;
+type index_WrappedExport = WrappedExport;
+declare const index_exportAsCompactJSON: typeof exportAsCompactJSON;
+declare const index_exportAsJSON: typeof exportAsJSON;
+declare const index_exportTierAsJSON: typeof exportTierAsJSON;
+declare const index_generateShortSummary: typeof generateShortSummary;
+declare const index_generateWrappedText: typeof generateWrappedText;
+declare const index_templates: typeof templates;
+declare namespace index {
+  export { type index_ExportMetadata as ExportMetadata, type index_WrappedExport as WrappedExport, index_exportAsCompactJSON as exportAsCompactJSON, index_exportAsJSON as exportAsJSON, index_exportTierAsJSON as exportTierAsJSON, index_generateShortSummary as generateShortSummary, index_generateWrappedText as generateWrappedText, index_templates as templates };
+}
+
+/**
+ * Claude Code Wrapped
+ *
+ * Generate Spotify Wrapped-style annual summaries of your Claude Code usage.
+ *
+ * @example
+ * ```typescript
+ * import { generateWrappedSummary } from "claude-code-wrapped";
+ *
+ * const result = await generateWrappedSummary({ year: 2025 });
+ *
+ * console.log(`Sessions: ${result.summary.core.sessions.total}`);
+ * console.log(`Cost: $${result.summary.core.estimatedCost.total.toFixed(2)}`);
+ * console.log(`Style: ${result.summary.tools.developerProfile.primaryStyle}`);
+ * ```
+ */
+
+/**
+ * Generate a complete Claude Code Wrapped summary
+ *
+ * @param config - Configuration options
+ * @returns Wrapped result containing summary, warnings, and stats
+ */
+declare function generateWrappedSummary(config?: ClaudeCodeWrappedConfig): Promise<WrappedResult<ClaudeCodeWrappedSummary>>;
+
+export { type ClaudeCodeWrappedConfig, type ClaudeCodeWrappedSummary, type ProcessingStats, type ResolvedConfig, type WrappedError, type WrappedResult, type WrappedWarning, exportAsCompactJSON, exportAsJSON, generateShortSummary, generateWrappedSummary, generateWrappedText, index$3 as loader, index$1 as metrics, index as output, index$2 as pricing, templates };