fix: preserve proper noun case in user dictionary (#72)

Fixed issue where user-added words like "Boston" were stored with original
case but displayed/predicted as lowercase.

Root cause: loadCustomAndUserWords() called .lowercase() on words when
loading into dictionary, losing the original case.

Fix:
- Added userWordOriginalCase map to track original case of user words
- Populate map when loading custom words (if word has uppercase)
- Apply original case to predictions via applyUserWordCase()
- Added helper methods applyUserWordCase() and applyUserWordCaseToList()
- Clear map on reload to prevent stale entries

Also added:
- preserveCapitalization() helper for autocorrect case preservation
- isIntentionallyCapitalized() to detect mid-sentence proper nouns

— claude-opus-4-5-20251101

Author: tribixbite

src/main/kotlin/tribixbite/cleverkeys/SuggestionHandler.kt

@@ -101,6 +101,49 @@ class SuggestionHandler(
         }
     }
 
+    /**
+     * Check if a capitalized word was intentionally capitalized (proper noun) vs auto-capitalized.
+     * Returns true if:
+     * 1. Word starts with uppercase
+     * 2. Word appears mid-sentence (not after sentence-ending punctuation or at text start)
+     *
+     * This detects intentional proper nouns like "Boston" typed mid-sentence.
+     *
+     * @param ic InputConnection to check surrounding text
+     * @param wordLength Length of the word just completed
+     * @return true if the capitalization appears intentional (proper noun)
+     */
+    private fun isIntentionallyCapitalized(ic: android.view.inputmethod.InputConnection?, wordLength: Int): Boolean {
+        if (ic == null || wordLength == 0) return false
+
+        // Get text before the word (before the word + space that was just typed)
+        // We need to look at what's before the word started
+        val textBefore = ic.getTextBeforeCursor(wordLength + 5, 0) ?: return false
+        if (textBefore.length <= wordLength) {
+            // Word is at the very start of text - auto-cap position
+            return false
+        }
+
+        // Get the character right before the word started
+        val beforeWordIndex = textBefore.length - wordLength - 1
+        if (beforeWordIndex < 0) return false
+
+        val charBefore = textBefore[beforeWordIndex]
+
+        // If preceded by sentence-ending punctuation, it's auto-cap position
+        if (charBefore in ".!?\n") return false
+
+        // If preceded by space, check what's before that space
+        if (charBefore == ' ' && beforeWordIndex > 0) {
+            val charBeforeSpace = textBefore[beforeWordIndex - 1]
+            // If space follows sentence-ending punctuation, it's auto-cap
+            if (charBeforeSpace in ".!?\n") return false
+        }
+
+        // Word is mid-sentence - capitalization was intentional
+        return true
+    }
+
     /**
      * Interface for sending debug logs to SwipeDebugActivity.
      * Implemented by CleverKeysService to bridge to its sendDebugLog method.

src/main/kotlin/tribixbite/cleverkeys/WordPredictor.kt

@@ -63,6 +63,10 @@ class WordPredictor {
     private var disabledWords: MutableSet<String> = mutableSetOf() // Cache of disabled words
     private var lastReloadTime: Long = 0
 
+    // Issue #72: Track original case of user-added words (proper nouns)
+    // Maps lowercase word to original case: "boston" -> "Boston"
+    private val userWordOriginalCase: MutableMap<String, String> = mutableMapOf()
+
     // OPTIMIZATION: Async loading state
     @Volatile
     private var isLoadingState: Boolean = false
@@ -239,6 +243,8 @@ class WordPredictor {
      */
     fun reloadCustomAndUserWords() {
         context?.let {
+            // Issue #72: Clear proper noun case map before reloading
+            userWordOriginalCase.clear()
             // v1.1.90: Pass currentLanguage to filter by locale
             val customWords = loadCustomAndUserWords(it, currentLanguage)
             // NOTE: Full rebuild needed here because we don't track which words were removed
@@ -354,6 +360,28 @@ class WordPredictor {
         return adaptationMultiplier > 1.0f
     }
 
+    /**
+     * Issue #72: Apply original case from user dictionary to a word.
+     * If user added "Boston" to dictionary, this transforms "boston" → "Boston".
+     *
+     * @param word Word to potentially restore case for (should be lowercase)
+     * @return Word with original case if found in user dictionary, otherwise unchanged
+     */
+    fun applyUserWordCase(word: String): String {
+        val lowerWord = word.lowercase()
+        return userWordOriginalCase[lowerWord] ?: word
+    }
+
+    /**
+     * Issue #72: Apply original case to a list of predictions.
+     *
+     * @param words List of predicted words
+     * @return List with proper noun case restored where applicable
+     */
+    fun applyUserWordCaseToList(words: List<String>): List<String> {
+        return words.map { applyUserWordCase(it) }
+    }
+
     /**
      * Add a word to the recent words list for language detection
      */
@@ -1212,10 +1240,16 @@ class WordPredictor {
                     val keys = jsonObj.keys()
                     var customCount = 0
                     while (keys.hasNext()) {
-                        val word = keys.next().lowercase()
-                        val frequency = jsonObj.optInt(word, 1000)
-                        dictionary.get()[word] = frequency
-                        loadedWords.add(word)  // Track loaded word
+                        val originalWord = keys.next()
+                        val lowerWord = originalWord.lowercase()
+                        val frequency = jsonObj.optInt(originalWord, 1000)
+                        dictionary.get()[lowerWord] = frequency
+                        loadedWords.add(lowerWord)  // Track loaded word
+                        // Issue #72: Preserve original case for proper nouns
+                        // Only store if word has uppercase (potential proper noun)
+                        if (originalWord != lowerWord) {
+                            userWordOriginalCase[lowerWord] = originalWord
+                        }
                         customCount++
                     }
                     if (BuildConfig.ENABLE_VERBOSE_LOGGING) {
@@ -1453,12 +1487,15 @@ class WordPredictor {
                 if (predictions.size >= maxPredictions) break
             }
 
+            // Issue #72: Apply proper noun case from user dictionary
+            val casedPredictions = applyUserWordCaseToList(predictions)
+
             if (BuildConfig.ENABLE_VERBOSE_LOGGING) {
-                Log.d(TAG, "Final predictions (${predictions.size}): $predictions")
+                Log.d(TAG, "Final predictions (${casedPredictions.size}): $casedPredictions")
                 Log.d(TAG, "Scores: $scores")
             }
 
-            return PredictionResult(predictions, scores)
+            return PredictionResult(casedPredictions, scores)
         } finally {
             android.os.Trace.endSection()
         }