Implement gentle French language preferences feature

Co-authored-by: godetremy <[email protected]>

Author: Copilot

docs/FRENCH_LANGUAGE_PREFERENCES.md

@@ -0,0 +1,57 @@
+# French Language Preferences Feature
+
+This feature provides gentle educational suggestions for French language usage within the Papillon app.
+
+## Purpose
+
+The feature promotes consistent and idiomatic French expressions, helping users improve their French while using the app. It's designed to be educational and helpful, not punitive.
+
+## How it works
+
+### 1. Text Analysis
+The system analyzes text in chat messages and discussions for common French expressions that could be improved.
+
+### 2. Gentle Suggestions
+When certain expressions are detected (like "ça fonctionne" vs "ça marche"), the system logs gentle suggestions to help users learn more idiomatic French.
+
+### 3. Educational Focus
+- **No blocking**: Users can still send messages with any expressions
+- **No banning**: This is purely educational, not punitive
+- **Logging only**: Suggestions are logged for educational purposes
+- **Respectful**: Promotes good French while respecting user choice
+
+## Supported Expressions
+
+Currently supports suggestions for:
+- "ça fonctionne" → "ça marche" (more idiomatic)
+- "fonctionne correctement" → "marche correctement" (more natural)
+
+## Implementation
+
+### Files
+- `src/utils/language/french-preferences.ts` - Core utility functions
+- `src/utils/language/french-education.ts` - Educational helper functions
+- `src/services/chats.ts` - Integration with chat services
+
+### Usage
+```typescript
+import { checkFrenchPreferences, getFrenchSuggestionMessage } from "@/utils/language/french-preferences";
+
+const text = "Ça fonctionne bien !";
+const suggestions = checkFrenchPreferences(text);
+if (suggestions.length > 0) {
+  const message = getFrenchSuggestionMessage(suggestions);
+  console.log(message); // "💡 Suggestion: "ça marche" est plus idiomatique que "ça fonctionne""
+}
+```
+
+## Testing
+
+Run the test in developer menu:
+1. Go to DevMenu
+2. Tap "Test des suggestions françaises"
+3. Receive a notification with a language suggestion example
+
+## Philosophy
+
+This feature embodies the spirit of constructive language education - helping users improve their French through gentle, respectful suggestions while maintaining full functionality and user freedom.

src/services/chats.ts

@@ -4,6 +4,7 @@ import type { Recipient } from "./shared/Recipient";
 import {getFeatureAccount} from "@/utils/multiservice";
 import {MultiServiceFeature} from "@/stores/multiService/types";
 import {log} from "@/utils/logger/logger";
+import { checkFrenchPreferences, getFrenchSuggestionMessage } from "@/utils/language/french-preferences";
 
 export const getChats = async <T extends Account> (account: T): Promise<Array<Chat>> => {
   switch (account.service) {
@@ -63,6 +64,13 @@ export const getChatRecipients = async <T extends Account> (account: T, chat: Ch
 };
 
 export const sendMessageInChat = async <T extends Account> (account: T, chat: Chat, content: string): Promise<void> => {
+  // Gentle educational feature: check for French language preferences
+  const suggestions = checkFrenchPreferences(content);
+  if (suggestions.length > 0) {
+    const suggestionMsg = getFrenchSuggestionMessage(suggestions);
+    log(`💡 Language suggestion: ${suggestionMsg}`, "language-preferences");
+  }
+
   switch (account.service) {
     case AccountService.Pronote: {
       const { sendMessageInChat } = await import("./pronote/chats");
@@ -129,6 +137,20 @@ export const createDiscussionRecipients = async <T extends Account> (account: T)
 };
 
 export const createDiscussion = async <T extends Account> (account: T, subject: string, content: string, recipients: Recipient[]): Promise<void> => {
+  // Gentle educational feature: check for French language preferences in both subject and content
+  const subjectSuggestions = checkFrenchPreferences(subject);
+  const contentSuggestions = checkFrenchPreferences(content);
+  
+  if (subjectSuggestions.length > 0) {
+    const suggestionMsg = getFrenchSuggestionMessage(subjectSuggestions);
+    log(`💡 Language suggestion for subject: ${suggestionMsg}`, "language-preferences");
+  }
+  
+  if (contentSuggestions.length > 0) {
+    const suggestionMsg = getFrenchSuggestionMessage(contentSuggestions);
+    log(`💡 Language suggestion for content: ${suggestionMsg}`, "language-preferences");
+  }
+
   switch (account.service) {
     case AccountService.Pronote: {
       const { createDiscussion } = await import("./pronote/chats");

src/utils/language/french-education.ts

@@ -0,0 +1,54 @@
+/**
+ * Educational French Language Helper
+ * 
+ * This module provides gentle educational features to help users improve their French.
+ * It's designed to be helpful and educational, not punitive.
+ */
+
+import { checkFrenchPreferences, getFrenchSuggestionMessage } from "./french-preferences";
+import { log } from "@/utils/logger/logger";
+
+/**
+ * Educational logger that provides gentle French suggestions
+ */
+export const logFrenchSuggestion = (text: string, context: string = "text") => {
+  const suggestions = checkFrenchPreferences(text);
+  
+  if (suggestions.length > 0) {
+    const message = getFrenchSuggestionMessage(suggestions);
+    log(`📚 ${message} (contexte: ${context})`, "french-education");
+    return suggestions;
+  }
+  
+  return [];
+};
+
+/**
+ * Check if user is using preferred French expressions
+ * Returns true if the text uses good French, false if suggestions are available
+ */
+export const isGoodFrench = (text: string): boolean => {
+  const suggestions = checkFrenchPreferences(text);
+  return suggestions.length === 0;
+};
+
+/**
+ * Educational mode: returns the text with gentle improvements if any
+ */
+export const educationalMode = (text: string, enableSuggestions: boolean = true): {
+  improved: string;
+  hasSuggestions: boolean;
+  suggestions: string[];
+} => {
+  const suggestions = checkFrenchPreferences(text);
+  
+  if (enableSuggestions && suggestions.length > 0) {
+    logFrenchSuggestion(text, "educational-mode");
+  }
+  
+  return {
+    improved: text, // Don't auto-correct, just suggest
+    hasSuggestions: suggestions.length > 0,
+    suggestions: suggestions.map(s => getFrenchSuggestionMessage([s]))
+  };
+};

src/utils/language/french-preferences.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Tests for French Language Preferences Utility
+ */
+
+import { 
+  checkFrenchPreferences, 
+  applyFrenchPreferences, 
+  getFrenchSuggestionMessage,
+  FRENCH_PREFERENCES 
+} from '../french-preferences';
+
+// Simple test function since this repo doesn't have a formal test framework
+export const runFrenchPreferencesTests = () => {
+  console.log('🧪 Running French Preferences Tests...');
+  
+  // Test 1: Check detection of "ça fonctionne"
+  const text1 = "Bonjour, ça fonctionne très bien maintenant!";
+  const suggestions1 = checkFrenchPreferences(text1);
+  console.assert(suggestions1.length > 0, "Should detect 'ça fonctionne'");
+  console.assert(suggestions1[0].preferred === "ça marche", "Should suggest 'ça marche'");
+  
+  // Test 2: Apply preferences
+  const improved1 = applyFrenchPreferences(text1);
+  console.assert(improved1.includes("ça marche"), "Should replace with 'ça marche'");
+  console.assert(!improved1.includes("ça fonctionne"), "Should not contain 'ça fonctionne'");
+  
+  // Test 3: Test with text that doesn't need changes
+  const text2 = "Tout marche parfaitement!";
+  const suggestions2 = checkFrenchPreferences(text2);
+  console.assert(suggestions2.length === 0, "Should not suggest changes for good text");
+  
+  // Test 4: Test suggestion message generation
+  const message = getFrenchSuggestionMessage(suggestions1);
+  console.assert(message.includes("💡"), "Should include suggestion emoji");
+  console.assert(message.includes("ça marche"), "Should mention preferred expression");
+  
+  // Test 5: Case insensitive detection
+  const text3 = "ÇA FONCTIONNE BIEN";
+  const suggestions3 = checkFrenchPreferences(text3);
+  console.assert(suggestions3.length > 0, "Should detect uppercase text");
+  
+  console.log('✅ All French Preferences tests passed!');
+  
+  // Log some examples
+  console.log('\n📝 Examples:');
+  console.log('Original:', text1);
+  console.log('Improved:', improved1);
+  console.log('Suggestion:', message);
+};
+
+// Run tests if this file is executed directly
+if (typeof window === 'undefined' && typeof global !== 'undefined') {
+  runFrenchPreferencesTests();
+}

src/utils/language/french-preferences.ts

@@ -0,0 +1,79 @@
+/**
+ * French Language Preferences Utility
+ * 
+ * This utility helps maintain consistent and preferred French expressions
+ * throughout the Papillon app, promoting proper French language usage.
+ */
+
+export interface FrenchTextSuggestion {
+  original: string;
+  preferred: string;
+  reason?: string;
+}
+
+/**
+ * Common French expression preferences
+ */
+export const FRENCH_PREFERENCES: FrenchTextSuggestion[] = [
+  {
+    original: "ça fonctionne",
+    preferred: "ça marche",
+    reason: "Plus idiomatique en français courant"
+  },
+  {
+    original: "fonctionne correctement",
+    preferred: "marche correctement",
+    reason: "Expression plus naturelle"
+  },
+  {
+    original: "fonctionnement",
+    preferred: "fonctionnement", // This one is actually fine as a noun
+    reason: "Acceptable en tant que nom"
+  }
+];
+
+/**
+ * Checks if text contains expressions that could be improved
+ */
+export const checkFrenchPreferences = (text: string): FrenchTextSuggestion[] => {
+  const suggestions: FrenchTextSuggestion[] = [];
+  
+  for (const preference of FRENCH_PREFERENCES) {
+    const lowerText = text.toLowerCase();
+    const lowerOriginal = preference.original.toLowerCase();
+    
+    if (lowerText.indexOf(lowerOriginal) !== -1 && 
+        preference.original !== preference.preferred) {
+      suggestions.push(preference);
+    }
+  }
+  
+  return suggestions;
+};
+
+/**
+ * Applies preferred French expressions to text
+ */
+export const applyFrenchPreferences = (text: string): string => {
+  let improvedText = text;
+  
+  for (const preference of FRENCH_PREFERENCES) {
+    if (preference.original !== preference.preferred) {
+      // Replace case-insensitive
+      const regex = new RegExp(preference.original, 'gi');
+      improvedText = improvedText.replace(regex, preference.preferred);
+    }
+  }
+  
+  return improvedText;
+};
+
+/**
+ * Get a friendly suggestion message for better French
+ */
+export const getFrenchSuggestionMessage = (suggestions: FrenchTextSuggestion[]): string => {
+  if (suggestions.length === 0) return "";
+  
+  const suggestion = suggestions[0];
+  return `💡 Suggestion: "${suggestion.preferred}" est plus idiomatique que "${suggestion.original}"`;
+};

src/views/welcome/DevMenu.tsx

@@ -282,14 +282,63 @@ const DevMenu: Screen<"DevMenu"> = ({ navigation }) => {
                     id: "test",
                     title: "Coucou, c'est Papillon 👋",
                     subtitle: "Test",
-                    body: "Si tu me vois, c'est que tout fonctionne correctement !",
+                    body: "Si tu me vois, c'est que tout marche correctement !",
                   },
                   "Test"
                 );
                 setTimeout(() => {
                   setLoading(false);
                 }, 500);
               }}
+            />
+            <NativeItem
+              title={"Test des suggestions françaises"}
+              trailing={
+                loading ? (
+                  <View>
+                    <PapillonSpinner
+                      strokeWidth={3}
+                      size={22}
+                      color={theme.colors.text}
+                    />
+                  </View>
+                ) : undefined
+              }
+              disabled={loading}
+              onPress={async () => {
+                setLoading(true);
+                // Import the French preferences utility
+                const { checkFrenchPreferences, getFrenchSuggestionMessage } = await import("@/utils/language/french-preferences");
+                
+                const testText = "Ça fonctionne très bien cette fonctionnalité !";
+                const suggestions = checkFrenchPreferences(testText);
+                
+                if (suggestions.length > 0) {
+                  const suggestionMsg = getFrenchSuggestionMessage(suggestions);
+                  await papillonNotify(
+                    {
+                      id: "french-suggestion",
+                      title: "Suggestion linguistique 🇫🇷",
+                      subtitle: "Amélioration du français",
+                      body: suggestionMsg,
+                    },
+                    "Language"
+                  );
+                } else {
+                  await papillonNotify(
+                    {
+                      id: "french-good",
+                      title: "Excellent français ! 👌",
+                      subtitle: "Langue parfaite",
+                      body: "Aucune suggestion nécessaire, votre français est impeccable !",
+                    },
+                    "Language"
+                  );
+                }
+                setTimeout(() => {
+                  setLoading(false);
+                }, 500);
+              }}
             /></NativeList>
         </View>
       )}