supervertaler 1.9.114__py3-none-any.whl → 1.9.128__py3-none-any.whl

Supervertaler.py

@@ -3,7 +3,7 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.114 (AI Assistant diagnostic logging)
+Version: 1.9.123 (QuickMenu now supports generic AI tasks)
 Release Date: January 19, 2026
 Framework: PyQt6
 
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.114"
+__version__ = "1.9.128"
 __phase__ = "0.9"
-__release_date__ = "2026-01-18"
+__release_date__ = "2026-01-19"
 __edition__ = "Qt"
 
 import sys
@@ -2559,7 +2559,7 @@ class EditableGridTextEditor(QTextEdit):
                     menu.addSeparator()
                 
                 # Add to dictionary action
-                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary", self)
+                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary (Alt+D)", self)
                 add_to_dict_action.triggered.connect(
                     lambda checked, w=misspelled_word: self._add_to_dictionary(w)
                 )
@@ -5322,7 +5322,7 @@ class SupervertalerQt(QMainWindow):
             dialog.exec()
             
             # Navigate to Settings → Features tab
-            self.main_tabs.setCurrentIndex(3)  # Settings tab
+            self.main_tabs.setCurrentIndex(4)  # Settings tab
             if hasattr(self, 'settings_tabs'):
                 # Find the Features tab index
                 for i in range(self.settings_tabs.count()):
@@ -5668,6 +5668,24 @@ class SupervertalerQt(QMainWindow):
         
         # Ctrl+Shift+2 - Quick add term with Priority 2
         create_shortcut("editor_quick_add_priority_2", "Ctrl+Shift+2", lambda: self._quick_add_term_with_priority(2))
+        
+        # Alt+D - Add word at cursor to dictionary
+        create_shortcut("editor_add_to_dictionary", "Alt+D", self.add_word_to_dictionary_shortcut)
+        
+        # Ctrl+N - Focus Segment Note tab
+        create_shortcut("editor_focus_notes", "Ctrl+N", self.focus_segment_notes)
+    
+    def focus_segment_notes(self):
+        """Switch to Segment Note tab and focus the notes editor so user can start typing immediately"""
+        if not hasattr(self, 'bottom_tabs'):
+            return
+        
+        # Switch to Segment note tab (index 1)
+        self.bottom_tabs.setCurrentIndex(1)
+        
+        # Focus the notes editor so user can start typing
+        if hasattr(self, 'bottom_notes_edit'):
+            self.bottom_notes_edit.setFocus()
     
     def refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
@@ -6307,12 +6325,16 @@ class SupervertalerQt(QMainWindow):
         go_resources_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(1) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_resources_action)
         
+        go_prompt_manager_action = QAction("🤖 &Prompt Manager", self)
+        go_prompt_manager_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(2) if hasattr(self, 'main_tabs') else None)
+        nav_menu.addAction(go_prompt_manager_action)
+        
         go_tools_action = QAction("🛠️ &Tools", self)
-        go_tools_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(2) if hasattr(self, 'main_tabs') else None)
+        go_tools_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(3) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_tools_action)
         
         go_settings_action = QAction("⚙️ &Settings", self)
-        go_settings_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(3) if hasattr(self, 'main_tabs') else None)
+        go_settings_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(4) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_settings_action)
         
         view_menu.addSeparator()
@@ -6800,6 +6822,9 @@ class SupervertalerQt(QMainWindow):
         settings_tab = self.create_settings_tab()
         self.main_tabs.addTab(settings_tab, "⚙️ Settings")
         
+        # Set startup tab to Grid (index 0)
+        self.main_tabs.setCurrentIndex(0)
+        
         main_layout.addWidget(self.main_tabs)
         
         # Connect tab changes to handle view refreshes
@@ -10829,6 +10854,38 @@ class SupervertalerQt(QMainWindow):
             self._play_sound_effect('glossary_term_error')
             self.statusBar().showMessage(f"Error adding term: {e}", 3000)
 
+    def add_word_to_dictionary_shortcut(self):
+        """Add word at cursor position to custom dictionary (Alt+D shortcut)
+        
+        Finds the misspelled word at the current cursor position and adds it to the
+        custom dictionary. Works when focus is in a grid target cell.
+        """
+        # Get currently focused widget
+        focused_widget = QApplication.focusWidget()
+        
+        # Check if we're in an editable grid cell
+        if not isinstance(focused_widget, EditableGridTextEditor):
+            self.statusBar().showMessage("Alt+D: Place cursor on a misspelled word in the target cell first", 3000)
+            return
+        
+        # Get cursor position
+        cursor = focused_widget.textCursor()
+        
+        # Try to find misspelled word at cursor
+        word_info = focused_widget._get_misspelled_word_at_cursor(cursor)
+        
+        if word_info[0] is None:
+            # No misspelled word found at cursor
+            self.statusBar().showMessage("No misspelled word at cursor position", 3000)
+            return
+        
+        word, start_pos, end_pos = word_info
+        
+        # Add to dictionary
+        focused_widget._add_to_dictionary(word)
+        
+        # Status message already shown by _add_to_dictionary
+
     def add_text_to_non_translatables(self, text: str):
         """Add selected text to active non-translatable list(s)"""
         if not text or not text.strip():
@@ -13427,7 +13484,9 @@ class SupervertalerQt(QMainWindow):
         
         # ===== TAB 2: AI Settings (LLM, Ollama) =====
         ai_tab = self._create_ai_settings_tab()
-        settings_tabs.addTab(scroll_area_wrapper(ai_tab), "🤖 AI Settings")
+        ai_scroll = scroll_area_wrapper(ai_tab)
+        settings_tabs.addTab(ai_scroll, "🤖 AI Settings")
+        self.ai_settings_scroll = ai_scroll  # Store reference for scrolling to API keys
         
         # ===== TAB 3: Language Pair Settings =====
         lang_tab = self._create_language_pair_tab()
@@ -13947,6 +14006,45 @@ class SupervertalerQt(QMainWindow):
         full_context_cb.stateChanged.connect(lambda: context_slider.setEnabled(full_context_cb.isChecked()))
         update_context_label(context_window_size)
         
+        prefs_layout.addSpacing(10)
+        
+        # QuickMenu document context
+        quickmenu_context_label = QLabel("<b>QuickMenu Document Context:</b>")
+        prefs_layout.addWidget(quickmenu_context_label)
+        
+        quickmenu_context_percent = general_prefs.get('quickmenu_context_percent', 50)
+        quickmenu_context_layout = QHBoxLayout()
+        quickmenu_context_layout.addWidget(QLabel("  Document context size:"))
+        quickmenu_context_slider = QSlider(Qt.Orientation.Horizontal)
+        quickmenu_context_slider.setMinimum(0)
+        quickmenu_context_slider.setMaximum(100)
+        quickmenu_context_slider.setValue(quickmenu_context_percent)
+        quickmenu_context_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        quickmenu_context_slider.setTickInterval(10)
+        quickmenu_context_layout.addWidget(quickmenu_context_slider)
+        quickmenu_context_value_label = QLabel(f"{quickmenu_context_percent}%")
+        quickmenu_context_value_label.setMinimumWidth(60)
+        quickmenu_context_layout.addWidget(quickmenu_context_value_label)
+        quickmenu_context_layout.addStretch()
+        prefs_layout.addLayout(quickmenu_context_layout)
+        
+        quickmenu_context_info = QLabel(
+            "  ⓘ When using {{DOCUMENT_CONTEXT}} placeholder in QuickMenu prompts.\n"
+            "  0% = disabled, 50% = half the document (default), 100% = entire document.\n"
+            "  Limit: maximum 100 segments for performance."
+        )
+        quickmenu_context_info.setStyleSheet("font-size: 9pt; color: #666; padding-left: 20px;")
+        quickmenu_context_info.setWordWrap(True)
+        prefs_layout.addWidget(quickmenu_context_info)
+        
+        def update_quickmenu_context_label(value):
+            if value == 0:
+                quickmenu_context_value_label.setText("0% (disabled)")
+            else:
+                quickmenu_context_value_label.setText(f"{value}%")
+        
+        quickmenu_context_slider.valueChanged.connect(update_quickmenu_context_label)
+        
         prefs_layout.addSpacing(5)
         
         # Check TM before API call
@@ -14091,7 +14189,8 @@ class SupervertalerQt(QMainWindow):
             batch_size_spin, surrounding_spin, full_context_cb, context_slider,
             check_tm_cb, auto_propagate_cb, delay_spin,
             ollama_keepwarm_cb,
-            llm_matching_cb, auto_markdown_cb, llm_spin
+            llm_matching_cb, auto_markdown_cb, llm_spin,
+            quickmenu_context_slider
         ))
         layout.addWidget(save_btn)
         
@@ -17089,7 +17188,8 @@ class SupervertalerQt(QMainWindow):
                                    batch_size_spin, surrounding_spin, full_context_cb, context_slider,
                                    check_tm_cb, auto_propagate_cb, delay_spin,
                                    ollama_keepwarm_cb,
-                                   llm_matching_cb, auto_markdown_cb, llm_spin):
+                                   llm_matching_cb, auto_markdown_cb, llm_spin,
+                                   quickmenu_context_slider):
         """Save all AI settings from the unified AI Settings tab"""
         # Determine selected provider
         if openai_radio.isChecked():
@@ -17148,6 +17248,7 @@ class SupervertalerQt(QMainWindow):
         general_prefs['surrounding_segments'] = surrounding_spin.value()
         general_prefs['use_full_context'] = full_context_cb.isChecked()
         general_prefs['context_window_size'] = context_slider.value()
+        general_prefs['quickmenu_context_percent'] = quickmenu_context_slider.value()
         general_prefs['check_tm_before_api'] = check_tm_cb.isChecked()
         general_prefs['auto_propagate_100'] = auto_propagate_cb.isChecked()
         general_prefs['lookup_delay'] = delay_spin.value()
@@ -31033,11 +31134,18 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         normalized_source = clean_source_lower
                         for quote_char in '\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A':
                             normalized_source = normalized_source.replace(quote_char, ' ')
+                        
+                        # CRITICAL FIX: Strip trailing punctuation from glossary term before matching
+                        # This allows entries like "De huidige uitvinding...problemen." (with period)
+                        # to match source text "...problemen." where tokenization strips the period
+                        # Strip from both ends to handle quotes and trailing punctuation
+                        normalized_term = source_term.lower().rstrip(PUNCT_CHARS).lstrip(PUNCT_CHARS)
+                        
                         # Check if term has punctuation - use different pattern
-                        if any(char in source_term for char in ['.', '%', ',', '-', '/']):
-                            pattern = re.compile(r'(?<!\w)' + re.escape(source_term.lower()) + r'(?!\w)')
+                        if any(char in normalized_term for char in ['.', '%', ',', '-', '/']):
+                            pattern = re.compile(r'(?<!\w)' + re.escape(normalized_term) + r'(?!\w)')
                         else:
-                            pattern = re.compile(r"\b" + re.escape(source_term.lower()) + r"\b")
+                            pattern = re.compile(r"\b" + re.escape(normalized_term) + r"\b")
                         
                         # Try matching on normalized (tag-stripped, quote-stripped) text first, 
                         # then tag-stripped, then original with tags
@@ -31494,7 +31602,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.case_sensitive_cb.setChecked(op.case_sensitive)
     
     def _fr_run_set_batch(self, fr_set: FindReplaceSet):
-        """Run all enabled operations in a F&R Set as a batch."""
+        """Run all enabled operations in a F&R Set as a batch (optimized for speed)."""
         enabled_ops = [op for op in fr_set.operations if op.enabled and op.find_text]
         
         if not enabled_ops:
@@ -31513,17 +31621,32 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Run each operation
-        total_replaced = 0
-        for op in enabled_ops:
-            count = self._execute_single_fr_operation(op)
-            total_replaced += count
-            self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+        # OPTIMIZATION: Disable UI updates during batch processing
+        self.table.setUpdatesEnabled(False)
         
-        # Refresh grid
-        self.load_segments_to_grid()
-        self.project_modified = True
-        self.update_window_title()
+        try:
+            # Run each operation
+            total_replaced = 0
+            for op in enabled_ops:
+                count = self._execute_single_fr_operation(op)
+                total_replaced += count
+                self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates and refresh only target column cells
+            self.table.setUpdatesEnabled(True)
+            # Update all target cells in-place (batch operations can affect many segments)
+            for row in range(len(self.current_project.segments)):
+                segment = self.current_project.segments[row]
+                target_widget = self.table.cellWidget(row, 3)
+                if target_widget and hasattr(target_widget, 'setPlainText'):
+                    target_widget.blockSignals(True)
+                    target_widget.setPlainText(segment.target)
+                    target_widget.blockSignals(False)
+            self.table.viewport().update()
         
         QMessageBox.information(
             self.find_replace_dialog,
@@ -31532,12 +31655,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         )
     
     def _execute_single_fr_operation(self, op: FindReplaceOperation) -> int:
-        """Execute a single F&R operation on all segments. Returns replacement count."""
+        """Execute a single F&R operation on all segments (optimized). Returns replacement count."""
         import re
         count = 0
         
+        # OPTIMIZATION: Pre-filter segments - only check segments that might contain the text
+        # Quick case-insensitive check to skip segments that definitely don't match
+        search_text_lower = op.find_text.lower() if not op.case_sensitive else None
+        
         for segment in self.current_project.segments:
             texts_to_check = []
+            
+            # Pre-filter: skip segments that can't possibly match
+            if not op.case_sensitive:
+                # Quick check: does the segment contain the search text at all?
+                skip_segment = True
+                if op.search_in in ("source", "both") and self.allow_replace_in_source:
+                    if search_text_lower in segment.source.lower():
+                        skip_segment = False
+                if op.search_in in ("target", "both"):
+                    if search_text_lower in segment.target.lower():
+                        skip_segment = False
+                if skip_segment:
+                    continue
+            
             if op.search_in in ("source", "both") and self.allow_replace_in_source:
                 texts_to_check.append(("source", segment.source))
             if op.search_in in ("target", "both"):
@@ -31833,7 +31974,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.find_next_match()
     
     def replace_all_matches(self):
-        """Replace all matches in target segments"""
+        """Replace all matches in target segments (optimized for speed)"""
         find_text = self.find_input.text()
         replace_text = self.replace_input.text()
         
@@ -31906,52 +32047,67 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Perform replacements
-        import re
-        replaced_count = 0
+        # OPTIMIZATION: Disable UI updates during batch replacement
+        self.table.setUpdatesEnabled(False)
         
-        for row, col in self.find_matches:
-            segment = self.current_project.segments[row]
-            
-            # Get the appropriate field
-            if col == 2:  # Source
-                old_text = segment.source
-            else:  # col == 3, Target
-                old_text = segment.target
+        try:
+            # Perform replacements
+            import re
+            replaced_count = 0
+            updated_rows = set()  # Track which rows need UI updates
             
-            # Perform replacement
-            if match_mode == 2:  # Entire segment
-                new_text = replace_text
-            else:
-                if case_sensitive:
-                    new_text = old_text.replace(find_text, replace_text)
-                else:
-                    pattern = re.escape(find_text)
-                    new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
-            
-            if new_text != old_text:
-                replaced_count += 1
-                # Update the appropriate field
-                if col == 2:
-                    segment.source = new_text
+            for row, col in self.find_matches:
+                segment = self.current_project.segments[row]
+                
+                # Get the appropriate field
+                if col == 2:  # Source
+                    old_text = segment.source
+                else:  # col == 3, Target
+                    old_text = segment.target
+                
+                # Perform replacement
+                if match_mode == 2:  # Entire segment
+                    new_text = replace_text
                 else:
-                    old_target = segment.target
-                    old_status = segment.status
-                    segment.target = new_text
-                    # Record undo state for find/replace operation
-                    self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    if case_sensitive:
+                        new_text = old_text.replace(find_text, replace_text)
+                    else:
+                        pattern = re.escape(find_text)
+                        new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
                 
-                # Update table
-                item = self.table.item(row, col)
-                if item:
-                    item.setText(new_text)
-        
-        self.project_modified = True
-        self.update_window_title()
-        
-        # Clear matches and reload
-        self.find_matches = []
-        self.load_segments_to_grid()
+                if new_text != old_text:
+                    replaced_count += 1
+                    updated_rows.add(row)
+                    
+                    # Update the appropriate field
+                    if col == 2:
+                        segment.source = new_text
+                    else:
+                        old_target = segment.target
+                        old_status = segment.status
+                        segment.target = new_text
+                        # Record undo state for find/replace operation
+                        self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    
+                    # OPTIMIZATION: Update only the affected cell widget in-place
+                    cell_widget = self.table.cellWidget(row, col)
+                    if cell_widget and hasattr(cell_widget, 'setPlainText'):
+                        cell_widget.blockSignals(True)
+                        cell_widget.setPlainText(new_text)
+                        cell_widget.blockSignals(False)
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+            # Clear matches
+            self.find_matches = []
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates without full grid reload
+            self.table.setUpdatesEnabled(True)
+            # Trigger a repaint of updated rows only
+            for row in updated_rows:
+                self.table.viewport().update()
         
         QMessageBox.information(self.find_replace_dialog, "Replace All", f"Replaced {replaced_count} occurrence(s).")
         self.log(f"✓ Replaced {replaced_count} occurrence(s) of '{find_text}'")
@@ -35941,11 +36097,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         except Exception as e:
             QMessageBox.warning(self, "Error", f"Could not open api_keys.txt: {str(e)}")
     
-    def _go_to_settings_tab(self):
-        """Navigate to Settings tab (from menu)"""
+    def _go_to_settings_tab(self, subtab_name: str = None):
+        """Navigate to Settings tab (from menu), optionally to a specific sub-tab
+        
+        Args:
+            subtab_name: Name of the sub-tab to navigate to (e.g., "AI Settings")
+        """
         if hasattr(self, 'main_tabs'):
-            # Main tabs: Grid=0, Project resources=1, Tools=2, Settings=3
-            self.main_tabs.setCurrentIndex(3)
+            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            self.main_tabs.setCurrentIndex(4)
+            
+            # Navigate to specific sub-tab if requested
+            if subtab_name and hasattr(self, 'settings_tabs'):
+                for i in range(self.settings_tabs.count()):
+                    if subtab_name.lower() in self.settings_tabs.tabText(i).lower():
+                        self.settings_tabs.setCurrentIndex(i)
+                        
+                        # If navigating to AI Settings, scroll to bottom (API keys section)
+                        if "ai settings" in subtab_name.lower() and hasattr(self, 'ai_settings_scroll'):
+                            # Use QTimer to ensure the tab is fully rendered before scrolling
+                            from PyQt6.QtCore import QTimer
+                            QTimer.singleShot(100, lambda: self.ai_settings_scroll.verticalScrollBar().setValue(
+                                self.ai_settings_scroll.verticalScrollBar().maximum()
+                            ))
+                        break
     
     def _go_to_superlookup(self):
         """Navigate to Superlookup in Tools tab"""
@@ -37177,7 +37352,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
                 )
                 if reply == QMessageBox.StandardButton.Yes:
-                    self._go_to_settings_tab()
+                    self._go_to_settings_tab("AI Settings")
                 return
             
             # Check if API key exists for selected provider
@@ -37536,7 +37711,17 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         return text.strip()
 
     def _quickmenu_build_custom_prompt(self, prompt_relative_path: str, source_text: str, source_lang: str, target_lang: str) -> str:
-        """Build a complete translation prompt using the chosen QuickMenu prompt as PRIMARY instructions."""
+        """Build a prompt for QuickMenu using the selected prompt as instructions.
+        
+        This is a GENERIC prompt builder (not translation-specific) that allows QuickMenu prompts
+        to do anything: explain, define, search, translate, analyze, etc.
+        
+        Supports placeholders:
+        - {{SELECTION}} or {{SOURCE_TEXT}} - The selected text
+        - {{SOURCE_LANGUAGE}} - Source language name
+        - {{TARGET_LANGUAGE}} - Target language name
+        - {{DOCUMENT_CONTEXT}} - Surrounding segments from the project for context
+        """
         if not hasattr(self, 'prompt_manager_qt') or not self.prompt_manager_qt:
             raise RuntimeError("Prompt manager not available")
 
@@ -37553,25 +37738,70 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if not prompt_content:
             raise RuntimeError("Prompt content is empty")
 
-        mode = getattr(pm, 'current_mode', None) or "single"
-        system_template = pm.get_system_template(mode)
-
-        system_template = system_template.replace("{{SOURCE_LANGUAGE}}", source_lang)
-        system_template = system_template.replace("{{TARGET_LANGUAGE}}", target_lang)
-        system_template = system_template.replace("{{SOURCE_TEXT}}", source_text)
+        # Build document context if requested
+        document_context = ""
+        if "{{DOCUMENT_CONTEXT}}" in prompt_content and hasattr(self, 'current_project') and self.current_project:
+            document_context = self._build_quickmenu_document_context()
 
-        library_prompts = "\n\n# PRIMARY INSTRUCTIONS\n\n" + prompt_content
-
-        # Keep any globally attached prompts as additional instructions
+        # Replace placeholders in the prompt content
+        prompt_content = prompt_content.replace("{{SOURCE_LANGUAGE}}", source_lang)
+        prompt_content = prompt_content.replace("{{TARGET_LANGUAGE}}", target_lang)
+        prompt_content = prompt_content.replace("{{SOURCE_TEXT}}", source_text)
+        prompt_content = prompt_content.replace("{{SELECTION}}", source_text)  # Alternative placeholder
+        prompt_content = prompt_content.replace("{{DOCUMENT_CONTEXT}}", document_context)
+        
+        # If the prompt doesn't contain the selection/text, append it
+        if "{{SOURCE_TEXT}}" not in prompt_data.get('content', '') and "{{SELECTION}}" not in prompt_data.get('content', ''):
+            prompt_content += f"\n\nText:\n{source_text}"
+        
+        return prompt_content
+    
+    def _build_quickmenu_document_context(self) -> str:
+        """Build document context for QuickMenu prompts.
+        
+        Returns a formatted string with segments from the project for context.
+        Uses the 'quickmenu_context_segments' setting (default: 50% of total segments).
+        """
+        if not hasattr(self, 'current_project') or not self.current_project or not self.current_project.segments:
+            return "(No project context available)"
+        
         try:
-            for attached_content in lib.attached_prompts:
-                library_prompts += "\n\n# ADDITIONAL INSTRUCTIONS\n\n" + (attached_content or "")
-        except Exception:
-            pass
-
-        final_prompt = system_template + library_prompts
-        final_prompt += "\n\n**YOUR TRANSLATION (provide ONLY the translated text, no numbering or labels):**\n"
-        return final_prompt
+            # Get settings
+            general_prefs = self.load_general_settings_from_file()
+            context_percent = general_prefs.get('quickmenu_context_percent', 50)  # Default: 50%
+            max_context_segments = general_prefs.get('quickmenu_context_max', 100)  # Safety limit
+            
+            # Calculate how many segments to include
+            total_segments = len(self.current_project.segments)
+            num_segments = min(
+                int(total_segments * context_percent / 100),
+                max_context_segments
+            )
+            
+            if num_segments == 0:
+                return "(Document context disabled)"
+            
+            # Get segments (from start of document)
+            context_segments = self.current_project.segments[:num_segments]
+            
+            # Format segments
+            context_parts = []
+            context_parts.append(f"=== DOCUMENT CONTEXT ===")
+            context_parts.append(f"(Showing {num_segments} of {total_segments} segments - {context_percent}%)")
+            context_parts.append("")
+            
+            for seg in context_segments:
+                # Source text
+                context_parts.append(f"[{seg.id}] {seg.source}")
+                # Target text if available
+                if seg.target and seg.target.strip():
+                    context_parts.append(f"    → {seg.target}")
+                context_parts.append("")  # Blank line between segments
+            
+            return "\n".join(context_parts)
+            
+        except Exception as e:
+            return f"(Error building document context: {e})"
 
     def _quickmenu_show_result_dialog(self, title: str, output_text: str, apply_callback=None):
         from PyQt6.QtWidgets import QDialog, QVBoxLayout, QTextEdit, QDialogButtonBox, QPushButton, QApplication
@@ -37651,10 +37881,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             )
 
             client = LLMClient(api_key=api_key, provider=provider, model=model)
+            
+            # Use translate() with empty text and custom_prompt for generic AI completion
+            # This allows QuickMenu prompts to do anything (explain, define, search, etc.)
+            # not just translation. Same pattern as AI Assistant.
             output_text = client.translate(
-                text=input_text,
-                source_lang=source_lang,
-                target_lang=target_lang,
+                text="",  # Empty - we're using custom_prompt for everything
+                source_lang="en",  # Dummy values
+                target_lang="en",
                 custom_prompt=custom_prompt
             )
 
@@ -39553,9 +39787,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
     def show_autofingers(self):
         """Show AutoFingers by switching to the AutoFingers tab"""
         # Find the AutoFingers tab index and activate it
-        # AutoFingers is in Tools tab (main_tabs index 2)
+        # AutoFingers is in Tools tab (main_tabs index 3)
         if hasattr(self, 'main_tabs'):
-            self.main_tabs.setCurrentIndex(2)  # Switch to Tools tab
+            self.main_tabs.setCurrentIndex(3)  # Switch to Tools tab
             # Then switch to AutoFingers sub-tab
             if hasattr(self, 'modules_tabs'):
                 for i in range(self.modules_tabs.count()):
@@ -44380,11 +44614,11 @@ class SuperlookupTab(QWidget):
             print(f"[Superlookup] Main window type: {type(main_window).__name__}")
             print(f"[Superlookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
             
-            # Switch to Tools tab (main_tabs index 2)
-            # Tab structure: Grid=0, Project resources=1, Tools=2, Settings=3
+            # Switch to Tools tab (main_tabs index 3)
+            # Tab structure: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
             if hasattr(main_window, 'main_tabs'):
                 print(f"[Superlookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
-                main_window.main_tabs.setCurrentIndex(2)  # Tools tab is at index 2
+                main_window.main_tabs.setCurrentIndex(3)  # Tools tab
                 print(f"[Superlookup] Switched to Tools tab (index 2)")
                 QApplication.processEvents()  # Force GUI update
             else: