Update index.html

index.html

@@ -583,14 +583,179 @@
       }
     }
 
-    // Common words for drill generation
-    const COMMON_WORDS = [
-      'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had',
-      'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'how',
-      'its', 'may', 'new', 'now', 'old', 'see', 'two', 'way', 'who', 'boy',
-      'did', 'car', 'let', 'put', 'say', 'she', 'too', 'use'
+    // Common words organized by difficulty and letter patterns
+    const WORD_CORPUS = {
+      // High-frequency words (top 100 most common)
+      common: [
+        'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'would', 'her',
+        'was', 'one', 'our', 'out', 'day', 'had', 'has', 'his', 'how', 'man',
+        'its', 'say', 'she', 'which', 'their', 'time', 'will', 'way', 'about',
+        'many', 'then', 'them', 'write', 'like', 'these', 'long', 'make', 'thing',
+        'see', 'him', 'two', 'look', 'more', 'go', 'come', 'number', 'sound',
+        'most', 'people', 'over', 'know', 'water', 'than', 'call', 'first'
+      ],
+      // Words with common digraphs
+      digraphs: {
+        'th': ['the', 'that', 'this', 'they', 'there', 'think', 'through', 'three', 'thanks', 'thought'],
+        'ch': ['change', 'check', 'choice', 'choose', 'chair', 'chance', 'charge', 'cheap', 'church', 'chapter'],
+        'sh': ['should', 'show', 'share', 'short', 'shape', 'sharp', 'shift', 'shine', 'shock', 'shoot'],
+        'wh': ['what', 'when', 'where', 'which', 'while', 'white', 'whole', 'whose', 'wheel', 'whether'],
+        'qu': ['quick', 'quite', 'quiet', 'queen', 'question', 'quality', 'quarter', 'square', 'require', 'equal'],
+        'ing': ['thing', 'being', 'doing', 'going', 'making', 'taking', 'coming', 'looking', 'working', 'thinking'],
+        'er': ['other', 'after', 'never', 'every', 'under', 'number', 'perhaps', 'better', 'together', 'remember'],
+        'ed': ['called', 'looked', 'asked', 'needed', 'wanted', 'worked', 'lived', 'turned', 'started', 'seemed']
+      },
+      // Words by difficulty (based on hand movements)
+      patterns: {
+        homeRow: ['had', 'ask', 'dad', 'sad', 'lad', 'fad', 'gas', 'has', 'lag', 'sag'],
+        topRow: ['were', 'your', 'trip', 'quit', 'power', 'write', 'quiet', 'worry', 'pretty', 'twenty'],
+        bottomRow: ['can', 'man', 'been', 'came', 'name', 'mean', 'become', 'common', 'woman', 'human'],
+        mixed: ['their', 'would', 'about', 'there', 'think', 'which', 'people', 'could', 'other', 'after']
+      },
+      // Common programming/tech words
+      technical: [
+        'function', 'variable', 'return', 'class', 'import', 'export', 'const', 'async', 'array', 'object',
+        'string', 'number', 'boolean', 'interface', 'public', 'private', 'static', 'method', 'property'
+      ]
+    };
+
+    // Sentence templates for more natural practice
+    const SENTENCE_TEMPLATES = [
+      "The {adjective} {noun} {verb} {preposition} the {noun}.",
+      "{pronoun} {verb} to {verb} the {adjective} {noun}.",
+      "Can you {verb} the {noun} {preposition} the {adjective} {noun}?",
+      "{number} {adjective} {noun}s {verb} {adverb} {preposition} the {noun}.",
+      "The {noun} {verb} {adjective} and {adjective}."
     ];
 
+    const WORD_TYPES = {
+      adjective: ['quick', 'brown', 'lazy', 'beautiful', 'small', 'large', 'happy', 'sad', 'fast', 'slow'],
+      noun: ['fox', 'dog', 'cat', 'house', 'tree', 'book', 'computer', 'phone', 'desk', 'chair'],
+      verb: ['jumps', 'runs', 'walks', 'sits', 'stands', 'writes', 'reads', 'types', 'thinks', 'works'],
+      pronoun: ['I', 'you', 'he', 'she', 'we', 'they', 'it'],
+      preposition: ['over', 'under', 'beside', 'through', 'across', 'behind', 'near', 'between'],
+      adverb: ['quickly', 'slowly', 'carefully', 'happily', 'quietly', 'loudly'],
+      number: ['two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
+    };
+
+    // Enhanced drill generator
+    function generateDrill(posteriors, length = 50) {
+      if (tracker.totalObservations < 20) {
+        // Start with common words for beginners
+        return "Type these common words: the quick brown fox jumps over the lazy dog. Practice makes perfect!";
+      }
+
+      // Calculate focus scores for each letter
+      const letterScores = Object.entries(posteriors)
+        .filter(([k, v]) => v.count > 0)
+        .map(([k, v]) => ({
+          key: k,
+          focus: v.mean * (v.sd + 0.1),
+          errorRate: v.mean,
+          uncertainty: v.sd
+        }))
+        .sort((a, b) => b.focus - a.focus);
+
+      // Get top problematic letters
+      const problemLetters = letterScores.slice(0, 5).map(s => s.key);
+      
+      // Categorize problem areas
+      const problemDigraphs = [];
+      const problemPatterns = [];
+      
+      // Check for problematic digraphs
+      for (const [digraph, words] of Object.entries(WORD_CORPUS.digraphs)) {
+        if (digraph.split('').some(letter => problemLetters.includes(letter))) {
+          problemDigraphs.push({ pattern: digraph, words });
+        }
+      }
+
+      // Build adaptive drill
+      let drill = [];
+      let currentLength = 0;
+      
+      // Mix different types of practice
+      while (currentLength < length) {
+        const random = Math.random();
+        
+        if (random < 0.4 && problemDigraphs.length > 0) {
+          // 40% - Focus on problematic digraphs
+          const digraph = problemDigraphs[Math.floor(Math.random() * problemDigraphs.length)];
+          const word = digraph.words[Math.floor(Math.random() * digraph.words.length)];
+          drill.push(word);
+          currentLength += word.length + 1;
+        } else if (random < 0.7) {
+          // 30% - Words containing problem letters
+          const targetLetter = problemLetters[Math.floor(Math.random() * Math.min(3, problemLetters.length))];
+          const candidates = [
+            ...WORD_CORPUS.common,
+            ...Object.values(WORD_CORPUS.patterns).flat()
+          ].filter(w => w.includes(targetLetter));
+          
+          if (candidates.length > 0) {
+            const word = candidates[Math.floor(Math.random() * candidates.length)];
+            drill.push(word);
+            currentLength += word.length + 1;
+          }
+        } else if (random < 0.85) {
+          // 15% - Common words for flow
+          const word = WORD_CORPUS.common[Math.floor(Math.random() * WORD_CORPUS.common.length)];
+          drill.push(word);
+          currentLength += word.length + 1;
+        } else {
+          // 15% - Generate a short sentence
+          if (currentLength + 20 < length) {
+            const sentence = generateSentence(problemLetters);
+            drill.push(sentence);
+            currentLength += sentence.length + 1;
+          }
+        }
+      }
+
+      // Format the drill nicely
+      const drillText = drill.join(' ').trim();
+      
+      // Add a note about what we're focusing on
+      const focusNote = problemLetters.length > 0 
+        ? `Focus areas: ${problemLetters.map(l => l.toUpperCase()).join(', ')} | `
+        : '';
+      
+      return focusNote + drillText;
+    }
+
+    // Generate sentences with problem letters
+    function generateSentence(problemLetters) {
+      const template = SENTENCE_TEMPLATES[Math.floor(Math.random() * SENTENCE_TEMPLATES.length)];
+      let sentence = template;
+      
+      // Replace placeholders with words containing problem letters when possible
+      for (const [type, words] of Object.entries(WORD_TYPES)) {
+        if (sentence.includes(`{${type}}`)) {
+          const candidates = words.filter(w => 
+            problemLetters.some(letter => w.includes(letter))
+          );
+          const wordList = candidates.length > 0 ? candidates : words;
+          const word = wordList[Math.floor(Math.random() * wordList.length)];
+          sentence = sentence.replace(`{${type}}`, word);
+        }
+      }
+      
+      return sentence;
+    }
+
+    // Update the initial target text
+    function getInitialText() {
+      const introTexts = [
+        "Welcome to adaptive typing practice. Start with this sentence to build your profile.",
+        "Type this paragraph to help me understand your typing patterns and create personalized drills.",
+        "Every keystroke teaches me about your typing style. Let's begin with this warm-up text.",
+        "Practice makes perfect. Begin typing to discover your unique strengths and challenges.",
+        "Your personalized typing journey starts here. Type this text to establish your baseline."
+      ];
+      
+      return introTexts[Math.floor(Math.random() * introTexts.length)];
+    }
+
     // Keyboard layout
     const KEY_ROWS = [ 
       ['q','w','e','r','t','y','u','i','o','p'], 
@@ -716,56 +881,88 @@
       });
     }
 
-    function generateDrill(posteriors, length = 40){
+    // Enhanced drill generator
+    function generateDrill(posteriors, length = 80) {
       if (tracker.totalObservations < 20) {
-        return "Type the target text above to build your personalized error model...";
+        // Start with common words for beginners
+        return "Type these common words: the quick brown fox jumps over the lazy dog. Practice makes perfect!";
       }
 
-      // Calculate focus scores
-      const scores = Object.entries(posteriors)
+      // Calculate focus scores for each letter
+      const letterScores = Object.entries(posteriors)
         .filter(([k, v]) => v.count > 0)
         .map(([k, v]) => ({
-          key: k, 
+          key: k,
           focus: v.mean * (v.sd + 0.1),
-          mean: v.mean,
-          sd: v.sd
-        }));
-      
-      scores.sort((a, b) => b.focus - a.focus);
+          errorRate: v.mean,
+          uncertainty: v.sd
+        }))
+        .sort((a, b) => b.focus - a.focus);
+
+      // Get top problematic letters
+      const problemLetters = letterScores.slice(0, 5).map(s => s.key);
       
-      // Get top problematic keys
-      const topKeys = scores.slice(0, Math.min(5, scores.length));
-      if (topKeys.length === 0) return "Great job! Keep practicing to maintain your skills.";
+      // Categorize problem areas
+      const problemDigraphs = [];
       
-      // Generate drill text
-      let drill = "";
-      const targetLength = length;
+      // Check for problematic digraphs
+      for (const [digraph, words] of Object.entries(WORD_CORPUS.digraphs)) {
+        if (digraph.split('').some(letter => problemLetters.includes(letter))) {
+          problemDigraphs.push({ pattern: digraph, words });
+        }
+      }
+
+      // Build adaptive drill
+      let drill = [];
+      let currentLength = 0;
       
-      while (drill.length < targetLength) {
-        // 70% chance to use a word containing problem keys
-        if (Math.random() < 0.7 && topKeys.length > 0) {
-          const targetKey = topKeys[Math.floor(Math.random() * topKeys.length)];
-          const wordsWithKey = COMMON_WORDS.filter(w => w.includes(targetKey.key));
+      // Mix different types of practice
+      while (currentLength < length) {
+        const random = Math.random();
+        
+        if (random < 0.4 && problemDigraphs.length > 0) {
+          // 40% - Focus on problematic digraphs
+          const digraph = problemDigraphs[Math.floor(Math.random() * problemDigraphs.length)];
+          const word = digraph.words[Math.floor(Math.random() * digraph.words.length)];
+          drill.push(word);
+          currentLength += word.length + 1;
+        } else if (random < 0.7) {
+          // 30% - Words containing problem letters
+          const targetLetter = problemLetters[Math.floor(Math.random() * Math.min(3, problemLetters.length))];
+          const candidates = [
+            ...WORD_CORPUS.common,
+            ...Object.values(WORD_CORPUS.patterns).flat()
+          ].filter(w => w.includes(targetLetter));
           
-          if (wordsWithKey.length > 0) {
-            drill += wordsWithKey[Math.floor(Math.random() * wordsWithKey.length)] + " ";
-          } else {
-            // If no common word contains the key, create a simple pattern
-            const patterns = [
-              targetKey.key + targetKey.key,
-              targetKey.key + "a" + targetKey.key,
-              targetKey.key + "e" + targetKey.key,
-              "a" + targetKey.key + "a"
-            ];
-            drill += patterns[Math.floor(Math.random() * patterns.length)] + " ";
+          if (candidates.length > 0) {
+            const word = candidates[Math.floor(Math.random() * candidates.length)];
+            drill.push(word);
+            currentLength += word.length + 1;
           }
+        } else if (random < 0.85) {
+          // 15% - Common words for flow
+          const word = WORD_CORPUS.common[Math.floor(Math.random() * WORD_CORPUS.common.length)];
+          drill.push(word);
+          currentLength += word.length + 1;
         } else {
-          // Add a random common word
-          drill += COMMON_WORDS[Math.floor(Math.random() * COMMON_WORDS.length)] + " ";
+          // 15% - Generate a short sentence
+          if (currentLength + 20 < length) {
+            const sentence = generateSentence(problemLetters);
+            drill.push(sentence);
+            currentLength += sentence.length + 1;
+          }
         }
       }
+
+      // Format the drill nicely
+      const drillText = drill.join(' ').trim();
+      
+      // Add a note about what we're focusing on
+      const focusNote = problemLetters.length > 0 
+        ? `Focus: ${problemLetters.slice(0,3).map(l => l.toUpperCase()).join(', ')} | `
+        : '';
       
-      return drill.trim();
+      return focusNote + drillText;
     }
 
     function updateExplanation(posteriors){
@@ -867,7 +1064,7 @@
       updateHeatmap(post);
       updateExplanation(post);
       
-      const drillText = generateDrill(post, 50);
+      const drillText = generateDrill(post, 80);
       drillDiv.textContent = drillText;
       
       updateStats(post);