supervertaler 1.9.116__py3-none-any.whl → 1.9.172__py3-none-any.whl

modules/ai_attachment_manager.py

@@ -29,15 +29,15 @@ class AttachmentManager:
         Initialize the AttachmentManager.
 
         Args:
-            base_dir: Base directory for attachments (default: user_data_private/AI_Assistant)
+            base_dir: Base directory for attachments (default: user_data_private/ai_assistant)
             log_callback: Function to call for logging messages
         """
         self.log = log_callback if log_callback else print
 
         # Set base directory
         if base_dir is None:
-            # Default to user_data_private/AI_Assistant
-            base_dir = Path("user_data_private") / "AI_Assistant"
+            # Default to user_data_private/ai_assistant
+            base_dir = Path("user_data_private") / "ai_assistant"
 
         self.base_dir = Path(base_dir)
         self.attachments_dir = self.base_dir / "attachments"

modules/config_manager.py

@@ -35,14 +35,14 @@ class ConfigManager:
     REQUIRED_FOLDERS = [
         # Note: Old numbered folders (1_System_Prompts, 2_Domain_Prompts, etc.) are deprecated
         # Migration moves them to unified Library structure
-        "Prompt_Library/Domain Expertise",
-        "Prompt_Library/Project Prompts",
-        "Prompt_Library/Style Guides",
-        "Translation_Resources/Termbases",
-        "Translation_Resources/TMs",
-        "Translation_Resources/Non-translatables",
-        "Translation_Resources/Segmentation_rules",
-        "Projects",
+        "prompt_library/domain_expertise",
+        "prompt_library/project_prompts",
+        "prompt_library/style_guides",
+        "resources/termbases",
+        "resources/tms",
+        "resources/non_translatables",
+        "resources/segmentation_rules",
+        "projects",
     ]
     
     def __init__(self):
@@ -268,8 +268,8 @@ class ConfigManager:
         Get the full path to a subfolder in user_data.
         
         Example:
-            config.get_subfolder_path('Translation_Resources/TMs')
-            -> '/home/user/Supervertaler_Data/Translation_Resources/TMs'
+            config.get_subfolder_path('resources/tms')
+            -> '/home/user/Supervertaler/resources/tms'
         """
         user_data_path = self.get_user_data_path()
         full_path = os.path.join(user_data_path, subfolder)

modules/database_manager.py

@@ -840,11 +840,15 @@ class DatabaseManager:
             bidirectional: If True, search both directions (nl→en AND en→nl)
         
         Returns: List of matches with similarity scores
+        
+        Note: When multiple TMs are provided, searches each TM separately to ensure
+        good matches from smaller TMs aren't pushed out by BM25 keyword ranking
+        from larger TMs. Results are merged and sorted by actual similarity.
         """
         # For better FTS5 matching, tokenize the query and escape special chars
         # FTS5 special characters: " ( ) - : , . ! ? 
         import re
-        from modules.tmx_generator import get_base_lang_code
+        from modules.tmx_generator import get_base_lang_code, get_lang_match_variants
         
         # Strip HTML/XML tags from source for clean text search
         text_without_tags = re.sub(r'<[^>]+>', '', source)
@@ -868,22 +872,57 @@ class DatabaseManager:
         # This helps find similar long segments more reliably
         search_terms_for_query = all_search_terms[:20]
         
-        print(f"[DEBUG] search_fuzzy_matches: source='{source[:50]}...', {len(all_search_terms)} terms")
-        
         if not search_terms_for_query:
             # If no valid terms, return empty results
-            print(f"[DEBUG] search_fuzzy_matches: No valid search terms, returning empty")
             return []
         
         # Quote each term to prevent FTS5 syntax errors
         fts_query = ' OR '.join(f'"{term}"' for term in search_terms_for_query)
-        print(f"[DEBUG] search_fuzzy_matches: FTS query terms = {search_terms_for_query[:10]}...")
         
         # Get base language codes for comparison
         src_base = get_base_lang_code(source_lang) if source_lang else None
         tgt_base = get_base_lang_code(target_lang) if target_lang else None
         
-        # Use FTS5 for initial candidate retrieval (fast)
+        # MULTI-TM FIX: Search each TM separately to avoid BM25 ranking issues
+        # When a large TM is combined with a small TM, the large TM's many keyword matches
+        # push down genuinely similar sentences from the small TM
+        tms_to_search = tm_ids if tm_ids else [None]  # None means search all TMs together
+        
+        all_results = []
+        
+        for tm_id in tms_to_search:
+            # Search this specific TM (or all if tm_id is None)
+            tm_results = self._search_single_tm_fuzzy(
+                source, fts_query, [tm_id] if tm_id else None,
+                threshold, max_results, src_base, tgt_base, 
+                source_lang, target_lang, bidirectional
+            )
+            all_results.extend(tm_results)
+        
+        # Deduplicate by source_text (keep highest similarity for each unique source)
+        seen = {}
+        for result in all_results:
+            key = result['source_text']
+            if key not in seen or result['similarity'] > seen[key]['similarity']:
+                seen[key] = result
+        
+        deduped_results = list(seen.values())
+        
+        # Sort ALL results by similarity (highest first) - this ensures the 76% match
+        # appears before 40% matches regardless of which TM they came from
+        deduped_results.sort(key=lambda x: x['similarity'], reverse=True)
+        
+        return deduped_results[:max_results]
+    
+    def _search_single_tm_fuzzy(self, source: str, fts_query: str, tm_ids: List[str],
+                                 threshold: float, max_results: int,
+                                 src_base: str, tgt_base: str,
+                                 source_lang: str, target_lang: str,
+                                 bidirectional: bool) -> List[Dict]:
+        """Search a single TM (or all TMs if tm_ids is None) for fuzzy matches"""
+        from modules.tmx_generator import get_lang_match_variants
+        
+        # Build query for this TM
         query = """
             SELECT tu.*, 
                    bm25(translation_units_fts) as relevance
@@ -893,13 +932,12 @@ class DatabaseManager:
         """
         params = [fts_query]
         
-        if tm_ids:
+        if tm_ids and tm_ids[0] is not None:
             placeholders = ','.join('?' * len(tm_ids))
             query += f" AND tu.tm_id IN ({placeholders})"
             params.extend(tm_ids)
         
         # Use flexible language matching (matches 'nl', 'nl-NL', 'Dutch', etc.)
-        from modules.tmx_generator import get_lang_match_variants
         if src_base:
             src_variants = get_lang_match_variants(source_lang)
             src_conditions = []
@@ -920,19 +958,16 @@ class DatabaseManager:
                 params.append(f"{variant}-%")
             query += f" AND ({' OR '.join(tgt_conditions)})"
         
-        # Get more candidates than needed for proper scoring (increase limit for long segments)
-        # Long segments need MANY more candidates because BM25 ranking may push down
-        # the truly similar entries in favor of entries matching more search terms
+        # Per-TM candidate limit - INCREASED to catch more potential fuzzy matches
+        # When multiple TMs are searched, BM25 ranking can push genuinely similar
+        # entries far down the list due to common word matches in other entries
         candidate_limit = max(500, max_results * 50)
         query += f" ORDER BY relevance DESC LIMIT {candidate_limit}"
         
-        print(f"[DEBUG] search_fuzzy_matches: Executing query (limit={candidate_limit})...")
-        
         try:
             self.cursor.execute(query, params)
             all_rows = self.cursor.fetchall()
         except Exception as e:
-            print(f"[DEBUG] search_fuzzy_matches: SQL ERROR: {e}")
             return []
         
         results = []
@@ -948,8 +983,6 @@ class DatabaseManager:
                 match_dict['match_pct'] = int(similarity * 100)
                 results.append(match_dict)
         
-        print(f"[DEBUG] search_fuzzy_matches: After threshold filter ({threshold}): {len(results)} matches")
-        
         # If bidirectional, also search reverse direction
         if bidirectional and src_base and tgt_base:
             query = """
@@ -961,13 +994,12 @@ class DatabaseManager:
             """
             params = [fts_query]
             
-            if tm_ids:
+            if tm_ids and tm_ids[0] is not None:
                 placeholders = ','.join('?' * len(tm_ids))
                 query += f" AND tu.tm_id IN ({placeholders})"
                 params.extend(tm_ids)
             
             # Reversed language filters with flexible matching
-            # For reverse: TM target_lang should match our source_lang, TM source_lang should match our target_lang
             src_variants = get_lang_match_variants(source_lang)
             tgt_variants = get_lang_match_variants(target_lang)
             
@@ -991,26 +1023,27 @@ class DatabaseManager:
             
             query += f" ORDER BY relevance DESC LIMIT {max_results * 5}"
             
-            self.cursor.execute(query, params)
-            
-            for row in self.cursor.fetchall():
-                match_dict = dict(row)
-                # Calculate similarity against target_text (since we're reversing)
-                similarity = self.calculate_similarity(source, match_dict['target_text'])
+            try:
+                self.cursor.execute(query, params)
                 
-                # Only include matches above threshold
-                if similarity >= threshold:
-                    # Swap source/target for reverse match
-                    match_dict['source_text'], match_dict['target_text'] = match_dict['target_text'], match_dict['source_text']
-                    match_dict['source_lang'], match_dict['target_lang'] = match_dict['target_lang'], match_dict['source_lang']
-                    match_dict['similarity'] = similarity
-                    match_dict['match_pct'] = int(similarity * 100)
-                    match_dict['reverse_match'] = True
-                    results.append(match_dict)
-        
-        # Sort by similarity (highest first) and limit results
-        results.sort(key=lambda x: x['similarity'], reverse=True)
-        return results[:max_results]
+                for row in self.cursor.fetchall():
+                    match_dict = dict(row)
+                    # Calculate similarity against target_text (since we're reversing)
+                    similarity = self.calculate_similarity(source, match_dict['target_text'])
+                    
+                    # Only include matches above threshold
+                    if similarity >= threshold:
+                        # Swap source/target for reverse match
+                        match_dict['source_text'], match_dict['target_text'] = match_dict['target_text'], match_dict['source_text']
+                        match_dict['source_lang'], match_dict['target_lang'] = match_dict['target_lang'], match_dict['source_lang']
+                        match_dict['similarity'] = similarity
+                        match_dict['match_pct'] = int(similarity * 100)
+                        match_dict['reverse_match'] = True
+                        results.append(match_dict)
+            except Exception as e:
+                print(f"[DEBUG] _search_single_tm_fuzzy (reverse): SQL ERROR: {e}")
+        
+        return results
     
     def search_all(self, source: str, tm_ids: List[str] = None, enabled_only: bool = True,
                    threshold: float = 0.75, max_results: int = 10) -> List[Dict]:
@@ -1124,6 +1157,12 @@ class DatabaseManager:
         Uses FTS5 full-text search for fast matching on millions of segments.
         Falls back to LIKE queries if FTS5 fails.
         
+        Language filters define what you're searching FOR and what translation you want:
+        - "From: Dutch, To: English" = Search for Dutch text, show English translations
+        - Searches ALL TMs (regardless of their stored language pair direction)
+        - Automatically swaps columns when needed (e.g., finds Dutch in target column of EN→NL TM)
+        - This is MORE intuitive than traditional CAT tools that only search specific TM directions
+        
         Args:
             query: Text to search for
             tm_ids: List of TM IDs to search (None = all)
@@ -1141,6 +1180,12 @@ class DatabaseManager:
         # Wrap in quotes for phrase search
         fts_query = f'"{fts_query}"'
         
+        # When language filters specified, we need to search intelligently:
+        # - Don't filter by TM language pair (search ALL TMs)
+        # - Search in BOTH columns to find text
+        # - Swap columns if needed to show correct language order
+        use_smart_search = (source_langs or target_langs)
+        
         try:
             # Use FTS5 for fast full-text search
             if direction == 'source':
@@ -1171,20 +1216,105 @@ class DatabaseManager:
                 fts_sql += f" AND tu.tm_id IN ({placeholders})"
                 params.extend(tm_ids)
             
-            # Add language filters (support for list of variants)
-            if source_langs:
-                placeholders = ','.join('?' * len(source_langs))
-                fts_sql += f" AND tu.source_lang IN ({placeholders})"
-                params.extend(source_langs)
-            if target_langs:
-                placeholders = ','.join('?' * len(target_langs))
-                fts_sql += f" AND tu.target_lang IN ({placeholders})"
-                params.extend(target_langs)
+            # DON'T filter by language when smart search active
+            # (we need to search all TMs and figure out which column has our language)
+            if not use_smart_search:
+                # Traditional filtering when no language filters
+                if source_langs:
+                    placeholders = ','.join('?' * len(source_langs))
+                    fts_sql += f" AND tu.source_lang IN ({placeholders})"
+                    params.extend(source_langs)
+                if target_langs:
+                    placeholders = ','.join('?' * len(target_langs))
+                    fts_sql += f" AND tu.target_lang IN ({placeholders})"
+                    params.extend(target_langs)
             
             fts_sql += " ORDER BY tu.modified_date DESC LIMIT 100"
             
             self.cursor.execute(fts_sql, params)
-            return [dict(row) for row in self.cursor.fetchall()]
+            raw_results = [dict(row) for row in self.cursor.fetchall()]
+            
+            # Smart search: Filter and swap based on language metadata
+            if use_smart_search:
+                processed_results = []
+                for row in raw_results:
+                    row_src_lang = row.get('source_lang', '')
+                    row_tgt_lang = row.get('target_lang', '')
+                    
+                    # Check if this row matches our language requirements
+                    # If "From: Dutch, To: English":
+                    # - Accept if source=nl and target=en (normal)
+                    # - Accept if source=en and target=nl (swap needed)
+                    
+                    matches = False
+                    needs_swap = False
+                    
+                    if source_langs and target_langs:
+                        # Both filters specified
+                        if row_src_lang in source_langs and row_tgt_lang in target_langs:
+                            # Perfect match - no swap
+                            matches = True
+                            needs_swap = False
+                        elif row_src_lang in target_langs and row_tgt_lang in source_langs:
+                            # Reversed - needs swap
+                            matches = True
+                            needs_swap = True
+                    elif source_langs:
+                        # Only "From" specified - just check if Dutch is in EITHER column
+                        if row_src_lang in source_langs:
+                            matches = True
+                            needs_swap = False
+                        elif row_tgt_lang in source_langs:
+                            matches = True
+                            needs_swap = True
+                    elif target_langs:
+                        # Only "To" specified - just check if English is in EITHER column
+                        if row_tgt_lang in target_langs:
+                            matches = True
+                            needs_swap = False
+                        elif row_src_lang in target_langs:
+                            matches = True
+                            needs_swap = True
+                    
+                    if matches:
+                        # CRITICAL CHECK: Verify the search text is actually in the correct column
+                        # If user searches for Dutch with "From: Dutch", the text must be in the source column (after any swap)
+                        # This prevents finding Dutch text when user asks to search FOR English
+                        
+                        if needs_swap:
+                            # After swap, check if query is in the NEW source column (was target)
+                            text_to_check = row['target_text'].lower()
+                        else:
+                            # No swap, check if query is in source column
+                            text_to_check = row['source_text'].lower()
+                        
+                        # Only include if query text is actually in the source column
+                        if query.lower() in text_to_check:
+                            if needs_swap:
+                                # Swap columns to show correct language order
+                                swapped_row = row.copy()
+                                swapped_row['source'] = row['target_text']
+                                swapped_row['target'] = row['source_text']
+                                swapped_row['source_lang'] = row['target_lang']
+                                swapped_row['target_lang'] = row['source_lang']
+                                processed_results.append(swapped_row)
+                            else:
+                                # No swap needed - just rename columns
+                                processed_row = row.copy()
+                                processed_row['source'] = row['source_text']
+                                processed_row['target'] = row['target_text']
+                                processed_results.append(processed_row)
+                
+                return processed_results
+            else:
+                # No language filters - just rename columns
+                processed_results = []
+                for row in raw_results:
+                    processed_row = row.copy()
+                    processed_row['source'] = row['source_text']
+                    processed_row['target'] = row['target_text']
+                    processed_results.append(processed_row)
+                return processed_results
             
         except Exception as e:
             # Fallback to LIKE query if FTS5 fails (e.g., index not built)
@@ -1312,6 +1442,10 @@ class DatabaseManager:
         # Note: termbase_id is stored as TEXT in termbase_terms but INTEGER in termbases
         # Use CAST to ensure proper comparison
         # IMPORTANT: Join with termbase_activation to get the ACTUAL priority for this project
+        # CRITICAL FIX: Also match when search_term starts with the glossary term
+        # This handles cases like searching for "ca." when glossary has "ca." 
+        # AND searching for "ca" when glossary has "ca."
+        # We also strip trailing punctuation from glossary terms for comparison
         query = """
             SELECT 
                 t.id, t.source_term, t.target_term, t.termbase_id, t.priority, 
@@ -1329,19 +1463,30 @@ class DatabaseManager:
                 LOWER(t.source_term) = LOWER(?) OR 
                 LOWER(t.source_term) LIKE LOWER(?) OR 
                 LOWER(t.source_term) LIKE LOWER(?) OR 
-                LOWER(t.source_term) LIKE LOWER(?)
+                LOWER(t.source_term) LIKE LOWER(?) OR
+                LOWER(RTRIM(t.source_term, '.!?,;:')) = LOWER(?) OR
+                LOWER(?) LIKE LOWER(t.source_term) || '%' OR
+                LOWER(?) = LOWER(RTRIM(t.source_term, '.!?,;:'))
             )
             AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
         """
-        # Exact match, word at start, word at end, word in middle
-        # Use LOWER() for case-insensitive matching (handles "Edelmetalen" = "edelmetalen")
-        # IMPORTANT: project_id must be first param for the LEFT JOIN ta.project_id = ? above
+        # Matching patterns:
+        # 1. Exact match: source_term = search_term
+        # 2. Glossary term starts with search: source_term LIKE "search_term %"
+        # 3. Glossary term ends with search: source_term LIKE "% search_term"
+        # 4. Glossary term contains search: source_term LIKE "% search_term %"
+        # 5. Glossary term (stripped) = search_term: RTRIM(source_term) = search_term (handles "ca." = "ca")
+        # 6. Search starts with glossary term: search_term LIKE source_term || '%' 
+        # 7. Search = glossary term stripped: search_term = RTRIM(source_term)
         params = [
             project_id if project_id else 0,  # Use 0 if no project (won't match any activation records)
             search_term,
             f"{search_term} %",
             f"% {search_term}",
-            f"% {search_term} %"
+            f"% {search_term} %",
+            search_term,  # For RTRIM comparison
+            search_term,  # For reverse LIKE
+            search_term   # For reverse RTRIM comparison
         ]
         
         # Language filters - if term has no language, use termbase language for filtering

modules/keyboard_shortcuts_widget.py

@@ -301,6 +301,10 @@ class KeyboardShortcutsWidget(QWidget):
     
     def load_shortcuts(self):
         """Load shortcuts into the table"""
+        # CRITICAL: Disable sorting during table modifications to prevent
+        # items from becoming disassociated from their rows (causes vanishing text bug)
+        self.table.setSortingEnabled(False)
+        
         self.table.setRowCount(0)
         
         all_shortcuts = self.manager.get_all_shortcuts()
@@ -362,6 +366,9 @@ class KeyboardShortcutsWidget(QWidget):
                 self.table.setItem(row, 4, status_item)
                 
                 row += 1
+        
+        # Re-enable sorting after all modifications are complete
+        self.table.setSortingEnabled(True)
     
     def _on_enabled_changed(self, state):
         """Handle checkbox state change for enabling/disabling shortcuts"""

modules/non_translatables_manager.py

@@ -172,7 +172,7 @@ class NonTranslatablesManager:
         Initialize manager.
         
         Args:
-            base_path: Base path for NT files (typically user_data/Translation_Resources/Non-translatables)
+            base_path: Base path for NT files (typically user_data/resources/non_translatables)
             log_callback: Optional logging function
         """
         self.base_path = Path(base_path)

modules/prompt_library_migration.py

@@ -29,7 +29,7 @@ class PromptLibraryMigration:
     def __init__(self, prompt_library_dir: str, log_callback=None):
         """
         Args:
-            prompt_library_dir: Path to user_data/Prompt_Library
+            prompt_library_dir: Path to user_data/prompt_library
             log_callback: Function for logging
         """
         self.prompt_library_dir = Path(prompt_library_dir)

modules/setup_wizard.py

@@ -80,17 +80,17 @@ class SetupWizard:
                 "Supervertaler will create the following structure:\n\n"
                 f"{self.selected_path}\n"
                 f"  ├── api_keys.txt\n"
-                f"  ├── Prompt_Library/\n"
+                f"  ├── prompt_library/\n"
                 f"  │   ├── 1_System_Prompts/\n"
                 f"  │   ├── 2_Domain_Prompts/\n"
                 f"  │   ├── 3_Project_Prompts/\n"
                 f"  │   └── 4_Style_Guides/\n"
-                f"  ├── Translation_Resources/\n"
+                f"  ├── resources/\n"
                 f"  │   ├── TMs/\n"
                 f"  │   ├── Glossaries/\n"
-                f"  │   ├── Non-translatables/\n"
-                f"  │   └── Segmentation_rules/\n"
-                f"  └── Projects/\n\n"
+                f"  │   ├── non_translatables/\n"
+                f"  │   └── segmentation_rules/\n"
+                f"  └── projects/\n\n"
                 "Is this correct?"
             )
             
@@ -140,9 +140,9 @@ class SetupWizard:
                 f"Your data folder: {self.selected_path}\n\n"
                 f"Created:\n"
                 f"  • api_keys.txt (add your API keys here)\n"
-                f"  • Prompt_Library/ (your prompts)\n"
-                f"  • Translation_Resources/ (TMs, glossaries)\n"
-                f"  • Projects/ (your work)\n\n"
+                f"  • prompt_library/ (your prompts)\n"
+                f"  • resources/ (TMs, glossaries)\n"
+                f"  • projects/ (your work)\n\n"
                 f"All your translation memories, prompts, and projects\n"
                 f"will be stored in this location."
             )

modules/shortcut_manager.py

@@ -18,9 +18,15 @@ class ShortcutManager:
         "file_new": {
             "category": "File",
             "description": "New Project",
-            "default": "Ctrl+N",
+            "default": "",
             "action": "new_project"
         },
+        "editor_focus_notes": {
+            "category": "Edit",
+            "description": "Focus Segment Note Tab (Ctrl+N)",
+            "default": "Ctrl+N",
+            "action": "focus_segment_notes"
+        },
         "file_open": {
             "category": "File",
             "description": "Open Project",
@@ -542,6 +548,28 @@ class ShortcutManager:
             "action": "copy_source_to_target",
             "context": "grid_editor"
         },
+        "editor_add_to_dictionary": {
+            "category": "Editor",
+            "description": "Add word at cursor to custom dictionary",
+            "default": "Alt+D",
+            "action": "add_word_to_dictionary",
+            "context": "grid_editor"
+        },
+        "editor_open_quickmenu": {
+            "category": "Editor",
+            "description": "Open QuickMenu for AI prompt actions",
+            "default": "Alt+K",
+            "action": "open_quickmenu",
+            "context": "grid_editor"
+        },
+        "editor_show_context_menu_double_shift": {
+            "category": "Editor",
+            "description": "Show context menu (double-tap Shift)",
+            "default": "",  # Requires AutoHotkey script: supervertaler_hotkeys.ahk
+            "action": "show_context_menu_double_shift",
+            "context": "grid_editor",
+            "note": "Requires AutoHotkey. Run supervertaler_hotkeys.ahk for this feature."
+        },
         
         # Filter Operations
         "filter_selected_text": {

modules/superbrowser.py

@@ -45,11 +45,12 @@ def _clear_corrupted_cache(storage_path: str):
 class ChatColumn(QWidget):
     """A column containing a chat interface with web browser"""
 
-    def __init__(self, title, url, header_color, parent=None):
+    def __init__(self, title, url, header_color, parent=None, user_data_path=None):
         super().__init__(parent)
         self.title = title
         self.url = url
         self.header_color = header_color
+        self.user_data_path = user_data_path  # Store user data path
         self.init_ui()
 
     def init_ui(self):
@@ -102,12 +103,14 @@ class ChatColumn(QWidget):
         profile_name = f"superbrowser_{self.title.lower()}"
         self.profile = QWebEngineProfile(profile_name, self)
         
-        # Set persistent storage path (use same pattern as main app)
-        # Check if running in dev mode (private data folder)
-        dev_mode_marker = os.path.join(os.path.dirname(__file__), "..", ".supervertaler.local")
-        base_folder = "user_data_private" if os.path.exists(dev_mode_marker) else "user_data"
-        
-        storage_path = os.path.join(os.path.dirname(__file__), "..", base_folder, "superbrowser_profiles", profile_name)
+        # Set persistent storage path using user_data_path from parent
+        if self.user_data_path:
+            storage_path = os.path.join(str(self.user_data_path), "superbrowser_profiles", profile_name)
+        else:
+            # Fallback to script directory if user_data_path not provided
+            dev_mode_marker = os.path.join(os.path.dirname(__file__), "..", ".supervertaler.local")
+            base_folder = "user_data_private" if os.path.exists(dev_mode_marker) else "user_data"
+            storage_path = os.path.join(os.path.dirname(__file__), "..", base_folder, "superbrowser_profiles", profile_name)
         os.makedirs(storage_path, exist_ok=True)
         
         # Clear potentially corrupted cache to prevent Chromium errors
@@ -166,9 +169,10 @@ class SuperbrowserWidget(QWidget):
     and concurrent interaction with different AI models.
     """
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, user_data_path=None):
         super().__init__(parent)
         self.parent_window = parent
+        self.user_data_path = user_data_path  # Store user data path for profiles
         
         # Default URLs for AI chat interfaces
         self.chatgpt_url = "https://chatgpt.com/"
@@ -257,10 +261,10 @@ class SuperbrowserWidget(QWidget):
         splitter = QSplitter(Qt.Orientation.Horizontal)
         splitter.setHandleWidth(3)
 
-        # Create chat columns
-        self.chatgpt_column = ChatColumn("ChatGPT", self.chatgpt_url, "#10a37f", self)
-        self.claude_column = ChatColumn("Claude", self.claude_url, "#c17c4f", self)
-        self.gemini_column = ChatColumn("Gemini", self.gemini_url, "#4285f4", self)
+        # Create chat columns - pass user_data_path for profile storage
+        self.chatgpt_column = ChatColumn("ChatGPT", self.chatgpt_url, "#10a37f", self, user_data_path=self.user_data_path)
+        self.claude_column = ChatColumn("Claude", self.claude_url, "#c17c4f", self, user_data_path=self.user_data_path)
+        self.gemini_column = ChatColumn("Gemini", self.gemini_url, "#4285f4", self, user_data_path=self.user_data_path)
 
         # Add columns to splitter
         splitter.addWidget(self.chatgpt_column)