supervertaler 1.9.147__py3-none-any.whl → 1.9.149__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

@@ -1124,6 +1124,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 +1147,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 +1183,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)

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/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)

modules/superlookup.py

@@ -157,9 +157,13 @@ class SuperlookupEngine:
                 
                 # Convert to LookupResult format (limit results)
                 for match in matches[:max_results]:
+                    # Use 'source' and 'target' keys (matches database column names)
+                    source_text = match.get('source', '')
+                    target_text = match.get('target', '')
+                    print(f"[Superlookup] Extracted: source='{source_text[:50]}...', target='{target_text[:50]}...'")
                     results.append(LookupResult(
-                        source=match.get('source', ''),
-                        target=match.get('target', ''),
+                        source=source_text,
+                        target=target_text,
                         match_percent=100,  # Concordance = contains the text
                         source_type='tm',
                         metadata={

modules/tmx_editor_qt.py

@@ -2655,7 +2655,7 @@ if __name__ == "__main__":
         os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".supervertaler.local")
     )
     user_data_path = Path("user_data_private" if ENABLE_PRIVATE_FEATURES else "user_data")
-    db_path = user_data_path / "Translation_Resources" / "supervertaler.db"
+    db_path = user_data_path / "resources" / "supervertaler.db"
     
     # Ensure database directory exists
     db_path.parent.mkdir(parents=True, exist_ok=True)

modules/translation_memory.py

@@ -401,7 +401,7 @@ class TMDatabase:
     
     def load_tmx_file(self, filepath: str, src_lang: str, tgt_lang: str, 
                       tm_name: str = None, read_only: bool = False, 
-                      strip_variants: bool = True) -> tuple[str, int]:
+                      strip_variants: bool = True, progress_callback=None) -> tuple[str, int]:
         """
         Load TMX file into a new custom TM
         
@@ -412,6 +412,7 @@ class TMDatabase:
             tm_name: Custom name for TM (default: filename)
             read_only: Make TM read-only
             strip_variants: Match base languages ignoring regional variants (default: True)
+            progress_callback: Optional callback function(current, total, message) for progress updates
         
         Returns: (tm_id, entry_count)
         """
@@ -423,16 +424,18 @@ class TMDatabase:
         self.add_custom_tm(tm_name, tm_id, read_only=read_only)
         
         # Load TMX content
-        loaded_count = self._load_tmx_into_db(filepath, src_lang, tgt_lang, tm_id, strip_variants=strip_variants)
+        loaded_count = self._load_tmx_into_db(filepath, src_lang, tgt_lang, tm_id, 
+                                             strip_variants=strip_variants, 
+                                             progress_callback=progress_callback)
         
         self.log(f"✓ Loaded {loaded_count} entries from {os.path.basename(filepath)}")
         
         return tm_id, loaded_count
     
     def _load_tmx_into_db(self, filepath: str, src_lang: str, tgt_lang: str, tm_id: str, 
-                          strip_variants: bool = False) -> int:
+                          strip_variants: bool = False, progress_callback=None) -> int:
         """
-        Internal: Load TMX content into database
+        Internal: Load TMX content into database with chunked processing
         
         Args:
             filepath: Path to TMX file
@@ -440,12 +443,24 @@ class TMDatabase:
             tgt_lang: Target target language code  
             tm_id: TM identifier
             strip_variants: If True, match base languages ignoring regional variants
+            progress_callback: Optional callback function(current, total, message) for progress updates
         """
         loaded_count = 0
+        chunk_size = 1000  # Process in chunks for responsiveness
+        chunk_buffer = []
         
         try:
+            # First pass: count total TUs for progress bar
+            if progress_callback:
+                progress_callback(0, 0, "Counting translation units...")
+            
             tree = ET.parse(filepath)
             root = tree.getroot()
+            total_tus = len(root.findall('.//tu'))
+            
+            if progress_callback:
+                progress_callback(0, total_tus, f"Processing 0 / {total_tus:,} entries...")
+            
             xml_ns = "http://www.w3.org/XML/1998/namespace"
             
             # Normalize language codes
@@ -458,6 +473,7 @@ class TMDatabase:
                 src_base = get_base_lang_code(src_lang_normalized)
                 tgt_base = get_base_lang_code(tgt_lang_normalized)
             
+            processed = 0
             for tu in root.findall('.//tu'):
                 src_text, tgt_text = None, None
                 
@@ -488,14 +504,43 @@ class TMDatabase:
                                 tgt_text = text
                 
                 if src_text and tgt_text:
+                    chunk_buffer.append((src_text, tgt_text))
+                    loaded_count += 1
+                    
+                    # Process chunk when buffer is full
+                    if len(chunk_buffer) >= chunk_size:
+                        for src, tgt in chunk_buffer:
+                            self.db.add_translation_unit(
+                                source=src,
+                                target=tgt,
+                                source_lang=src_lang_normalized,
+                                target_lang=tgt_lang_normalized,
+                                tm_id=tm_id
+                            )
+                        chunk_buffer.clear()
+                        
+                        # Update progress
+                        if progress_callback:
+                            progress_callback(processed + 1, total_tus, 
+                                            f"Processing {loaded_count:,} / {total_tus:,} entries...")
+                
+                processed += 1
+            
+            # Process remaining entries in buffer
+            if chunk_buffer:
+                for src, tgt in chunk_buffer:
                     self.db.add_translation_unit(
-                        source=src_text,
-                        target=tgt_text,
+                        source=src,
+                        target=tgt,
                         source_lang=src_lang_normalized,
                         target_lang=tgt_lang_normalized,
                         tm_id=tm_id
                     )
-                    loaded_count += 1
+                chunk_buffer.clear()
+            
+            # Final progress update
+            if progress_callback:
+                progress_callback(total_tus, total_tus, f"Completed: {loaded_count:,} entries imported")
             
             return loaded_count
         except Exception as e:

modules/unified_prompt_library.py

@@ -30,7 +30,7 @@ class UnifiedPromptLibrary:
         Initialize the Unified Prompt Library.
         
         Args:
-            library_dir: Path to unified library directory (user_data/Prompt_Library/Library)
+            library_dir: Path to unified library directory (user_data/prompt_library)
             log_callback: Function to call for logging messages
         """
         self.library_dir = Path(library_dir) if library_dir else None

modules/unified_prompt_manager_qt.py

@@ -544,8 +544,8 @@ class UnifiedPromptManagerQt:
         self.log = parent_app.log if hasattr(parent_app, 'log') else print
         
         # Paths
-        self.prompt_library_dir = self.user_data_path / "Prompt_Library"
-        # Use Prompt_Library directly, not Prompt_Library/Library
+        self.prompt_library_dir = self.user_data_path / "prompt_library"
+        # Use prompt_library directly, not prompt_library/Library
         self.unified_library_dir = self.prompt_library_dir
 
         # Run migration if needed
@@ -579,7 +579,7 @@ class UnifiedPromptManagerQt:
         self._cached_document_markdown: Optional[str] = None  # Cached markdown conversion of current document
 
         # Initialize Attachment Manager
-        ai_assistant_dir = self.user_data_path / "AI_Assistant"
+        ai_assistant_dir = self.user_data_path / "ai_assistant"
         self.attachment_manager = AttachmentManager(
             base_dir=str(ai_assistant_dir),
             log_callback=self.log_message
@@ -640,7 +640,7 @@ class UnifiedPromptManagerQt:
 
         # Tab 1: Prompt Library
         library_tab = self._create_prompt_library_tab()
-        self.sub_tabs.addTab(library_tab, "📚 Prompt Library")
+        self.sub_tabs.addTab(library_tab, "📚 Library")
 
         # Tab 2: AI Assistant (placeholder for now)
         assistant_tab = self._create_ai_assistant_tab()
@@ -694,7 +694,7 @@ class UnifiedPromptManagerQt:
         layout.setSpacing(5)
         
         # Title
-        title = QLabel("🤖 Prompt Manager")
+        title = QLabel("⚡ QuickMenu")
         title.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
         layout.addWidget(title, 0)
         
@@ -1546,7 +1546,7 @@ class UnifiedPromptManagerQt:
     
     def _create_active_config_panel(self) -> QGroupBox:
         """Create active prompt configuration panel"""
-        group = QGroupBox("Active Configuration")
+        group = QGroupBox("Active Prompt")
         layout = QVBoxLayout()
         
         # Mode info (read-only, auto-selected)
@@ -1704,10 +1704,10 @@ class UnifiedPromptManagerQt:
         self.editor_quickmenu_label_input.setPlaceholderText("Label shown in QuickMenu")
         quickmenu_layout.addWidget(self.editor_quickmenu_label_input, 2)
 
-        self.editor_quickmenu_in_grid_cb = CheckmarkCheckBox("Show in Grid right-click QuickMenu")
+        self.editor_quickmenu_in_grid_cb = CheckmarkCheckBox("Show in QuickMenu (in-app)")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_grid_cb, 2)
 
-        self.editor_quickmenu_in_quickmenu_cb = CheckmarkCheckBox("Show in Supervertaler QuickMenu")
+        self.editor_quickmenu_in_quickmenu_cb = CheckmarkCheckBox("Show in QuickMenu (global)")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_quickmenu_cb, 1)
 
         layout.addLayout(quickmenu_layout)
@@ -1760,26 +1760,7 @@ class UnifiedPromptManagerQt:
             item.setFlags(item.flags() | Qt.ItemFlag.ItemIsDragEnabled)
             favorites_root.addChild(item)
         
-        # QuickMenu section (legacy kind name: quick_run)
-        quick_run_root = QTreeWidgetItem(["⚡ QuickMenu"])
-        # Special node: not draggable/droppable
-        quick_run_root.setData(0, Qt.ItemDataRole.UserRole, {'type': 'special', 'kind': 'quick_run'})
-        quick_run_root.setExpanded(False)
-        font = quick_run_root.font(0)
-        font.setBold(True)
-        quick_run_root.setFont(0, font)
-        self.tree_widget.addTopLevelItem(quick_run_root)
-        
-        quickmenu_items = self.library.get_quickmenu_prompts() if hasattr(self.library, 'get_quickmenu_prompts') else self.library.get_quick_run_prompts()
-        self.log_message(f"🔍 DEBUG: QuickMenu count: {len(quickmenu_items)}")
-        for path, label in quickmenu_items:
-            item = QTreeWidgetItem([label])
-            item.setData(0, Qt.ItemDataRole.UserRole, {'type': 'prompt', 'path': path})
-            # Quick Run entries are shortcuts, but allow dragging to move the actual prompt file.
-            item.setFlags(item.flags() | Qt.ItemFlag.ItemIsDragEnabled)
-            quick_run_root.addChild(item)
-        
-        # Library folders
+        # Library folders (QuickMenu parent folder removed - folder hierarchy now defines menu structure)
         self.log_message(f"🔍 DEBUG: Building tree from {self.unified_library_dir}")
         self._build_tree_recursive(None, self.unified_library_dir, "")
         
@@ -3548,7 +3529,7 @@ Output complete ACTION."""
         """
         Save the markdown conversion of the current document.
 
-        Saves to: user_data_private/AI_Assistant/current_document/
+        Saves to: user_data_private/ai_assistant/current_document/
 
         Args:
             original_path: Original document file path
@@ -3556,7 +3537,7 @@ Output complete ACTION."""
         """
         try:
             # Create directory for current document markdown
-            doc_dir = self.user_data_path / "AI_Assistant" / "current_document"
+            doc_dir = self.user_data_path / "ai_assistant" / "current_document"
             doc_dir.mkdir(parents=True, exist_ok=True)
 
             # Create filename based on original