feat: add Enter key support and random newlines in practice content

Add Enter key input handling with visual `↵` icon display and
implement random newlines in practice generators for more engaging
and realistic typing practice.

Features:
- Enter key support with `\n` character validation
- Visual `↵` icon for newlines in expected text and typed input
- Random separator logic: 25% newline, 75% space in practice drills
- Preserved newline handling in text wrapping and cursor positioning

Changes:
- Input handler: Add KeyCode::Enter case (app.rs)
- Text rendering: Preserve newlines in wrap_text(), display `↵` icon (render.rs)
- Content generators: Add random newline separators (bigram, trigram, finger, key pair)
- Tests: Add Enter key validation tests, update deterministic tests for randomization

Documentation:
- Add special character visualization section to TUI design doc
- Update bigram generator design with random separator example
- Note Enter/newline support in CLAUDE.md constraints

Quality:
- All 148 tests passing
- Clippy warnings fixed (len_zero, manual_range_contains)
- Code formatted with cargo fmt

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: jrollin

CLAUDE.md

@@ -155,6 +155,8 @@ src/
 - AZERTY keyboard only (Phase 1-2)
 - French language only (Phase 1-2)
 - Backspace support enabled (Phase 1+)
+- Enter/newline support with `↵` icon visualization
+- Random newlines in practice content (25% probability)
 - No sound effects (all phases)
 - Terminal-only (no GUI)
 

docs/features/bigram-training/design.md

@@ -135,11 +135,14 @@ impl BigramGenerator {
 ```rust
 fn generate_drill_mode(&self, bigrams: Vec<&Bigram>, length: usize) -> String {
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let mut idx = 0;
 
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            // Random separator: 25% newline, 75% space
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
 
         let bigram = &bigrams[idx % bigrams.len()];
@@ -153,7 +156,7 @@ fn generate_drill_mode(&self, bigrams: Vec<&Bigram>, length: usize) -> String {
     result.chars().take(length).collect()
 }
 
-// Output: "qu qu qu ou ou ou en en en qu qu qu..."
+// Output: "qu qu qu ou ou ou\nen en en qu qu qu..." (random newlines)
 ```
 
 **2. Word Mode (Level 2)**: Bigrams in word context

docs/features/tui-interface/design.md

@@ -144,6 +144,30 @@ fn render_cursor() -> Span {
 - Doesn't require special terminal support
 - Works consistently across terminals
 
+### Special Character Visualization
+
+**Non-printable character icons:**
+```rust
+fn display_char(ch: char) -> char {
+    match ch {
+        ' ' => '·',      // U+00B7 Middle Dot for spaces
+        '\n' => '↵',     // U+21B5 Downwards Arrow for newlines
+        c => c,
+    }
+}
+```
+
+**Design rationale:**
+- **Space (·)**: Makes whitespace visible without being distracting
+- **Newline (↵)**: Clearly indicates line breaks in multi-line content
+- Icons shown in both expected text and typed input for consistency
+- Preserves color coding (green/red/gray) to maintain feedback
+
+**Implementation notes:**
+- Icons are display-only; actual characters stored remain unchanged
+- Enter key input is validated against '\n' character
+- Newline support enables practice with code snippets and structured content
+
 ## Real-time Updates
 
 ### Render Loop

examples/verify_adaptive.rs

@@ -61,7 +61,7 @@ fn main() {
 
                 if accuracy < 80.0 && total >= 10.0 {
                     weak_keys.push((key, accuracy));
-                } else if accuracy >= 80.0 && accuracy < 95.0 {
+                } else if (80.0..95.0).contains(&accuracy) {
                     moderate_keys.push((key, accuracy));
                 } else if accuracy >= 95.0 {
                     strong_keys.push((key, accuracy));

src/app.rs

@@ -496,6 +496,11 @@ impl App {
                         session.add_input(c);
                     }
                 }
+                KeyCode::Enter => {
+                    if let Some(session) = &mut self.session {
+                        session.add_input('\n');
+                    }
+                }
                 KeyCode::Backspace => {
                     if let Some(session) = &mut self.session {
                         session.remove_last_input();

src/content/bigram_generator.rs

@@ -1,5 +1,6 @@
 /// Content generator for bigram training lessons
 use super::bigram::{code_bigrams, english_bigrams, french_bigrams, Bigram, BigramType, Language};
+use rand::Rng;
 
 pub struct BigramGenerator {
     bigrams: Vec<Bigram>,
@@ -52,11 +53,13 @@ impl BigramGenerator {
     /// Example: "qu qu qu ou ou ou en en en"
     fn generate_drill_mode(&self, bigrams: &[&Bigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut idx = 0;
 
         while result.len() < length {
             if !result.is_empty() {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             let bigram = bigrams[idx % bigrams.len()];
@@ -76,11 +79,13 @@ impl BigramGenerator {
     /// Example: "que qui quoi pour vous nous"
     fn generate_word_mode(&self, bigrams: &[&Bigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut bigram_idx = 0;
 
         while result.len() < length {
             if !result.is_empty() {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             let bigram = bigrams[bigram_idx % bigrams.len()];
@@ -100,11 +105,13 @@ impl BigramGenerator {
     /// Combines examples into natural-looking phrases
     fn generate_mixed_mode(&self, bigrams: &[&Bigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut word_count = 0;
 
         while result.len() < length {
             if word_count > 0 {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             // Pick a bigram
@@ -206,13 +213,16 @@ mod tests {
     }
 
     #[test]
-    fn test_deterministic_generation() {
+    fn test_random_newlines_in_generation() {
         let gen = BigramGenerator::new(BigramType::Natural, Some(Language::French));
 
-        let content1 = gen.generate(2, 40);
-        let content2 = gen.generate(2, 40);
+        let content = gen.generate(2, 100);
 
-        // Same level and length should produce same content
-        assert_eq!(content1, content2);
+        // Content should contain both spaces and newlines (random mix)
+        assert!(content.contains(' '));
+        // Content should have expected words from top bigrams
+        assert!(content.contains("les") || content.contains("de") || content.contains("en"));
+        // Content length should respect constraint
+        assert!(content.chars().count() <= 100);
     }
 }

src/content/code_generator.rs

@@ -36,7 +36,7 @@ impl CodeSymbolGenerator {
 
         while result.len() < length {
             if !result.is_empty() {
-                result.push(' ');
+                result.push('\n');
             }
 
             let snippet = &filtered_snippets[idx % filtered_snippets.len()];

src/content/finger_generator.rs

@@ -1,6 +1,7 @@
 use crate::content::lesson::FingerPairType;
 use crate::keyboard::azerty::{AzertyLayout, Finger, RowType};
 use rand::seq::SliceRandom;
+use rand::Rng;
 
 /// Extract keys assigned to a specific finger pair at a given difficulty level
 pub fn get_finger_pair_keys(
@@ -82,6 +83,7 @@ pub fn generate_finger_drills(keys: &[char], length: usize, with_shift: bool) ->
 /// Generate drills with only base characters (3-phase pattern)
 fn generate_base_drills(keys: &[char], length: usize) -> String {
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let mut patterns = Vec::new();
 
     // Phase 1: Single key repetitions (warm-up)
@@ -117,8 +119,9 @@ fn generate_base_drills(keys: &[char], length: usize) -> String {
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
-            // Check if adding space would exceed length
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
+            // Check if adding separator would exceed length
             if result.len() >= length {
                 break;
             }
@@ -206,8 +209,9 @@ fn generate_shift_drills(keys: &[char], length: usize) -> String {
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
-            // Check if adding space would exceed length
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
+            // Check if adding separator would exceed length
             if result.len() >= length {
                 break;
             }

src/content/generator.rs

@@ -95,6 +95,7 @@ fn generate_two_key_drills(keys: &[char], length: usize) -> String {
     }
 
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let pattern = [
         format!("{}{}", keys[0], keys[0]),
         format!("{}{}", keys[1], keys[1]),
@@ -103,7 +104,8 @@ fn generate_two_key_drills(keys: &[char], length: usize) -> String {
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
         result.push_str(&pattern[idx % pattern.len()]);
         idx += 1;
@@ -122,6 +124,7 @@ fn generate_progressive_drills(keys: &[char], length: usize) -> String {
     }
 
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let mut patterns = Vec::new();
 
     // Phase 1: Répétitions de chaque touche
@@ -151,7 +154,8 @@ fn generate_progressive_drills(keys: &[char], length: usize) -> String {
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
         result.push_str(&patterns[idx % patterns.len()]);
         idx += 1;
@@ -172,11 +176,13 @@ fn generate_words(_keys: &[char], length: usize) -> String {
     ];
 
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let mut idx = 0;
 
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
         result.push_str(words[idx % words.len()]);
         idx += 1;
@@ -193,6 +199,7 @@ fn generate_key_pair_drills(keys: &[char], length: usize) -> String {
     }
 
     let mut result = String::new();
+    let mut rng = rand::thread_rng();
     let mut patterns = Vec::new();
 
     // Phase 1: Single key repetitions (warm-up)
@@ -228,7 +235,8 @@ fn generate_key_pair_drills(keys: &[char], length: usize) -> String {
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
         result.push_str(&patterns[idx % patterns.len()]);
         idx += 1;
@@ -331,7 +339,8 @@ fn generate_shift_variant_drills(group: &super::lesson::KeyPairGroupDef, length:
     let mut idx = 0;
     while result.len() < length {
         if !result.is_empty() {
-            result.push(' ');
+            let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+            result.push(separator);
         }
         result.push_str(&patterns[idx % patterns.len()]);
         idx += 1;
@@ -346,9 +355,11 @@ mod tests {
 
     #[test]
     fn test_generate_two_key_drills() {
-        let result = generate_two_key_drills(&['f', 'j'], 15);
-        assert!(result.starts_with("ff jj ff jj"));
-        assert!(result.len() <= 15);
+        let result = generate_two_key_drills(&['f', 'j'], 30);
+        // Should contain both patterns (may have spaces or newlines between)
+        assert!(result.contains("ff"));
+        assert!(result.contains("jj"));
+        assert!(result.len() <= 30);
     }
 
     #[test]

src/content/trigram_generator.rs

@@ -1,6 +1,7 @@
 /// Content generator for trigram training lessons
 use super::bigram::Language;
 use super::trigram::{english_trigrams, french_trigrams, Trigram};
+use rand::Rng;
 
 pub struct TrigramGenerator {
     trigrams: Vec<Trigram>,
@@ -49,11 +50,13 @@ impl TrigramGenerator {
     /// Example: "the the the and and and"
     fn generate_drill_mode(&self, trigrams: &[&Trigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut idx = 0;
 
         while result.len() < length {
             if !result.is_empty() {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             let trigram = trigrams[idx % trigrams.len()];
@@ -73,11 +76,13 @@ impl TrigramGenerator {
     /// Example: "the them then and hand stand"
     fn generate_word_mode(&self, trigrams: &[&Trigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut trigram_idx = 0;
 
         while result.len() < length {
             if !result.is_empty() {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             let trigram = trigrams[trigram_idx % trigrams.len()];
@@ -97,11 +102,13 @@ impl TrigramGenerator {
     /// Combines examples into natural-looking phrases
     fn generate_mixed_mode(&self, trigrams: &[&Trigram], length: usize) -> String {
         let mut result = String::new();
+        let mut rng = rand::thread_rng();
         let mut word_count = 0;
 
         while result.len() < length {
             if word_count > 0 {
-                result.push(' ');
+                let separator = if rng.gen_bool(0.25) { '\n' } else { ' ' };
+                result.push(separator);
             }
 
             // Pick a trigram
@@ -195,14 +202,17 @@ mod tests {
     }
 
     #[test]
-    fn test_deterministic_generation() {
+    fn test_random_newlines_in_generation() {
         let gen = TrigramGenerator::new(Language::French);
 
-        let content1 = gen.generate(2, 40);
-        let content2 = gen.generate(2, 40);
+        let content = gen.generate(2, 100);
 
-        // Same level and length should produce same content
-        assert_eq!(content1, content2);
+        // Content should contain both spaces and newlines (random mix)
+        assert!(content.contains(' '));
+        // Content should have expected words from top trigrams
+        assert!(content.contains("les") || content.contains("des") || content.contains("ment"));
+        // Content length should respect constraint
+        assert!(content.chars().count() <= 100);
     }
 
     #[test]