Struct UserStats 

pub struct UserStats {
    pub lessons_completed: HashSet<String>,
    pub lessons_by_difficulty: HashMap<Difficulty, usize>,
    pub commands_used: HashSet<String>,
    pub total_commands_executed: usize,
    pub current_streak: usize,
    pub longest_streak: usize,
    pub last_active_date: NaiveDate,
    pub total_time_seconds: u64,
    pub session_start: DateTime<Utc>,
    pub achievements: UserAchievements,
    pub completed_challenges: HashSet<String>,
}

Comprehensive user statistics and progress tracking

Fields

lessons_completed: HashSet<String>

Set of completed lesson IDs

lessons_by_difficulty: HashMap<Difficulty, usize>

Count of lessons completed by difficulty level

commands_used: HashSet<String>

Set of unique commands that have been used

total_commands_executed: usize

Total number of commands executed (including duplicates)

current_streak: usize

Current consecutive days streak

longest_streak: usize

Longest streak ever achieved

last_active_date: NaiveDate

Last date the user was active

total_time_seconds: u64

Total time spent in the app (seconds)

session_start: DateTime<Utc>

When the current session started

achievements: UserAchievements

User’s achievement progress

completed_challenges: HashSet<String>

Completed challenges (for exploration/challenge achievements)

Implementations

impl UserStats

pub fn new() -> Self

Create a new user stats tracker

pub fn update_streak(&mut self)

Update the streak based on current date

pub fn record_lesson_completion( &mut self, lesson_id: String, difficulty: Difficulty, )

Record completion of a lesson

pub fn record_command_use(&mut self, command: String)

Record use of a command

pub fn complete_challenge(&mut self, challenge_id: String)

Mark a challenge as completed

pub fn record_event(&mut self, event_key: &str) -> Vec<Achievement>

Record a one-shot feature-usage event from the UI layer and return any newly unlocked achievements.

The TUI should call this at the corresponding feature-usage call sites. Recognized event keys (each backs a CompleteChallenge achievement condition, see achievement::all_achievements):

• "use_ai" — the AI assistant was invoked/toggled
• "change_theme" — the user changed the color theme
• "visit_all_panels" — the user has visited every panel at least once
• "use_context" — the context detection feature was used
• "speed_lesson" — a lesson was completed in under 5 minutes
• "perfect_lesson" — a lesson was completed without failed attempts
• "first_challenge" — the user completed their first daily/weekly challenge (sent automatically by ChallengeManager::check_command)

Calling this repeatedly with the same key is safe (idempotent).

pub fn check_achievements(&mut self) -> Vec<Achievement>

Check all achievements against the built-in lesson library and return newly unlocked ones.

If user lessons have been loaded via LessonLibrary::load_from_dir, prefer check_achievements_with_library so per-difficulty totals are accurate.

pub fn check_achievements_with_library( &mut self, library: &LessonLibrary, ) -> Vec<Achievement>

Check all achievements using real per-difficulty lesson counts from the given library, and return newly unlocked ones.

pub fn completion_percentage(&self, difficulty: Difficulty) -> f32

Calculate completion percentage for a difficulty level, based on the built-in lesson library. Use completion_percentage_with_library when user lessons have been loaded.

pub fn completion_percentage_with_library( &self, difficulty: Difficulty, library: &LessonLibrary, ) -> f32

Calculate completion percentage for a difficulty level using real lesson counts from the given library.

pub fn overall_completion_percentage(&self, total_lessons: usize) -> f32

Get overall completion percentage across all lessons

pub fn update_session_time(&mut self)

Update total time spent so “Time Invested” accumulates.

This is the TUI heartbeat API: call it periodically (e.g. once per render tick or once a minute) AND on session end / before persisting stats. Each call folds the elapsed time since session_start into total_time_seconds and resets session_start to now, so calling it at any frequency never double-counts time.

pub fn formatted_time_spent(&self) -> String

Get formatted time spent string (e.g., “2h 30m”)

pub fn progress_summary(&self) -> ProgressSummary

Get progress summary

pub fn nearly_unlocked_achievements(&self) -> Vec<(Achievement, f32)>

Get achievements that are close to being unlocked (for motivation)

Trait Implementations

impl Clone for UserStats

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UserStats

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UserStats

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UserStats

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for UserStats

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.