A few minor tweaks in preparation for release.

README.md

@@ -12,6 +12,8 @@ This software is licensed under the LGPL v3.
 - **Multiple Interface Support**: Works in Linux TTY, and terminal emulators
 - **Flexible Driver System**: Modular architecture with multiple drivers for speech, sound, input, and screen
 - **Review Mode**: Navigate and review screen content without moving the edit cursor
+- **Table Navigation**: Advanced table mode with column headers, cell-by-cell navigation, and boundary feedback
+- **Progress Bar Monitoring**: Automatic detection and audio feedback for progress indicators with ascending tones
 - **Multiple Clipboard Support**: Manage multiple clipboard entries
 - **Configurable Key Bindings**: Desktop and laptop keyboard layouts
 - **Sound Icons**: Audio feedback for various events
@@ -156,6 +158,7 @@ By default Fenrir uses:
    - `Keypad 2` - Read current character
    - `Fenrir + T` - Announce time
    - `Fenrir + S` - Spell check current word
+   - `Fenrir + Keypad *` - Toggle table mode / highlight tracking
 
 ### Keyboard Layouts
 
@@ -402,6 +405,176 @@ setting <action> [parameters]
 - `time#delaySec=seconds` - Announcement interval
 - `time#onMinutes=00,30` - Specific minutes to announce
 
+## Table Navigation
+
+Fenrir includes advanced table navigation capabilities for working with tabular data in terminal applications, CSV files, and formatted text output.
+
+### Entering Table Mode
+
+Table mode is activated through the **toggle_highlight_tracking** command, which cycles through three focus modes:
+
+1. **Highlight tracking mode** (default) - Follows text highlighting
+2. **Cursor tracking mode** - Follows text cursor movement
+3. **Table mode** - Enables table navigation
+
+**Key bindings:**
+- **Desktop layout**: `Fenrir + Keypad *` (asterisk)
+- **Laptop layout**: `Fenrir + Y`
+
+Press the key combination repeatedly to cycle through modes until you hear "table mode enabled".
+
+### Table Navigation Commands
+
+#### Column Navigation (Desktop Layout)
+- **Next column**: `Keypad 6` - Move to next table column
+- **Previous column**: `Keypad 4` - Move to previous table column
+- **First column**: `Fenrir + Keypad 4` - Jump to first column of current row
+- **Last column**: `Fenrir + Keypad 6` - Jump to last column of current row
+
+#### Column Navigation (Laptop Layout)
+- **Next column**: `Fenrir + L` - Move to next table column
+- **Previous column**: `Fenrir + J` - Move to previous table column
+- **First column**: `Fenrir + Shift + J` - Jump to first column of current row
+- **Last column**: `Fenrir + Shift + L` - Jump to last column of current row
+
+#### Cell Character Navigation
+- **First character in cell**: `Fenrir + Keypad 1` (desktop) or `Fenrir + Ctrl + J` (laptop)
+- **Last character in cell**: `Fenrir + Keypad 3` (desktop) or `Fenrir + Ctrl + L` (laptop)
+
+### Setting Column Headers
+
+For better navigation experience, you can set column headers:
+
+1. **Navigate to header row**: Use normal navigation to reach the row containing column headers
+2. **Set headers**: Press `Fenrir + X` to mark the current line as the header row
+3. **Navigation feedback**: Column headers will be announced along with cell content
+
+### Table Detection
+
+Fenrir automatically detects table structures using multiple strategies:
+- **Delimited text**: CSV, pipe-separated (`|`), semicolon-separated (`;`), tab-separated
+- **Aligned columns**: Space-aligned columns (2+ spaces between columns)
+- **Flexible parsing**: Handles various table formats commonly found in terminal applications
+
+### Table Mode Features
+
+- **Cell-by-cell navigation**: Navigate through table cells with precise positioning
+- **Column header support**: Set and announce column headers for better context
+- **Boundary feedback**: Audio cues when reaching start/end of rows
+- **Empty cell handling**: Blank cells are announced as "blank"
+- **Independent tracking**: Table position is maintained independently of cursor movement
+
+### Speech Output in Table Mode
+
+When navigating in table mode, Fenrir announces:
+- **Cell content** followed by **column header/name**
+- **Boundary notifications**: "end of line", "start of line"
+- **Position indicators**: "first character in cell [column name]"
+
+### Example Usage
+
+```bash
+# Working with CSV data
+cat data.csv
+Name,Age,City
+Alice,30,New York
+Bob,25,Los Angeles
+
+# 1. Press Fenrir + Keypad * until "table mode enabled"
+# 2. Navigate to "Name,Age,City" line
+# 3. Press Fenrir + X to set headers
+# 4. Use Keypad 4/6 to navigate between columns
+# 5. Each cell will be announced with its column header
+```
+
+## Progress Bar Monitoring
+
+Fenrir provides intelligent progress bar detection and audio feedback for various progress indicators commonly found in terminal applications.
+
+### Enabling Progress Monitoring
+
+**Command**: `progress_bar_monitor` (no default key binding - assign manually)
+
+To enable progress monitoring:
+1. Add a key binding in your keyboard layout file
+2. Or use the remote control system: `echo "command progress_bar_monitor" | socat - UNIX-CLIENT:/tmp/fenrirscreenreader-deamon.sock`
+
+### Progress Detection Patterns
+
+Fenrir automatically detects various progress indicator formats:
+
+#### 1. Percentage Progress
+```
+Download: 45%
+Processing: 67.5%
+Installing: 100%
+```
+
+#### 2. Fraction Progress
+```
+Files: 15/100
+Progress: 3 of 10
+Step 7/15
+```
+
+#### 3. Progress Bars
+```
+[####      ] 40%
+[====>     ] 50%
+[**********] 100%
+```
+
+#### 4. Activity Indicators
+```
+Loading...
+Processing...
+Working...
+Installing...
+Downloading...
+Compiling...
+Building...
+```
+
+### Audio Feedback
+
+#### Progress Tones
+- **Ascending tones**: 400Hz to 1200Hz frequency range
+- **Percentage mapping**: 0% = 400Hz, 100% = 1200Hz
+- **Smooth progression**: Frequency increases proportionally with progress
+
+#### Activity Indicators
+- **Steady beep**: 800Hz tone every 2 seconds for ongoing activity
+- **Non-intrusive**: Beeps don't interrupt speech or other audio
+
+### Progress Monitoring Features
+
+- **Automatic detection**: No manual configuration required
+- **Multiple format support**: Handles various progress indicator styles
+- **Prompt awareness**: Automatically pauses when command prompts are detected
+- **Non-blocking**: Progress tones don't interrupt speech or other functionality
+- **Configurable**: Can be enabled/disabled as needed
+
+### Usage Examples
+
+```bash
+# Enable progress monitoring
+echo "command progress_bar_monitor" | socat - UNIX-CLIENT:/tmp/fenrirscreenreader-deamon.sock
+
+# Common scenarios where progress monitoring is useful:
+wget https://example.com/large-file.zip    # Download progress
+tar -xvf archive.tar.gz                    # Extraction progress
+make -j4                                   # Compilation progress
+pacman -S package                          # Package installation
+rsync -av source/ destination/             # File synchronization
+```
+
+### Customization
+
+Progress monitoring can be configured through settings:
+- **Default enabled**: Set `progressMonitoring=True` in sound section
+- **Sound integration**: Works with all sound drivers (sox, gstreamer)
+- **Remote control**: Enable/disable through remote commands
+
 ### Scripting Examples
 
 #### Bash Script for Speech Notifications

check-dependencies.py

@@ -50,7 +50,7 @@ def check_dependency(dep: Dependency) -> bool:
 dependencyList = [
     # Core dependencies
     Dependency('FenrirCore', 'core', 'core', 
-              pythonImports=['daemonize', 'enchant']),
+              pythonImports=['daemonize', 'enchant', 'pyperclip', 'setproctitle']),
     
     # Screen drivers
     Dependency('DummyScreen', 'screen', 'dummyDriver'),
@@ -58,7 +58,7 @@ dependencyList = [
               pythonImports=['dbus'],
               devicePaths=['/dev/vcsa']),
     Dependency('PTY', 'screen', 'ptyDriver',
-              pythonImports=['pyte']),
+              pythonImports=['pyte', 'xdg']),
               
     # Input drivers
     Dependency('DummyInput', 'input', 'dummyDriver'),
@@ -82,7 +82,11 @@ dependencyList = [
     Dependency('Speechd', 'speech', 'speechdDriver',
               pythonImports=['speechd']),
     Dependency('GenericSpeech', 'speech', 'genericDriver',
-              checkCommands=['espeak-ng'])
+              checkCommands=['espeak-ng']),
+              
+    # Additional dependencies
+    Dependency('Pexpect', 'core', 'pexpectDriver',
+              pythonImports=['pexpect'])
 ]
 
 defaultModules = {
@@ -90,7 +94,8 @@ defaultModules = {
     'VCSA',
     'Evdev',
     'GenericSpeech',
-    'GenericSound'
+    'GenericSound',
+    'Pexpect'
 }
 
 def check_all_dependencies():

config/keyboard/Readme.md

@@ -1,4 +1,46 @@
 
+# Fenrir Keyboard Configuration
+
+This directory contains keyboard layout files for Fenrir screen reader.
+
+## Available Layouts
+
+- **desktop.conf** - Desktop layout using numeric keypad (recommended)
+- **laptop.conf** - Laptop layout for keyboards without numeric keypad
+- **nvda-desktop.conf** - NVDA-compatible desktop layout
+- **nvda-laptop.conf** - NVDA-compatible laptop layout
+- **pty.conf** - PTY emulation layout for terminal use
+- **pty2.conf** - Alternative PTY emulation layout
+
+## Key Features
+
+### Table Navigation
+- **Toggle table mode**: `Fenrir + Keypad *` (desktop) or `Fenrir + Y` (laptop)
+- **Column navigation**: `Keypad 4/6` (desktop) or `Fenrir + J/L` (laptop)
+- **Row boundaries**: `Fenrir + Keypad 4/6` (desktop) or `Fenrir + Shift + J/L` (laptop)
+- **Set headers**: `Fenrir + X` in table mode
+
+### Progress Bar Monitoring
+- **Monitor progress**: `progress_bar_monitor` command (assign key binding manually)
+- **Auto-detection**: Percentage, fractions, progress bars, activity indicators
+- **Audio feedback**: Ascending tones (400Hz-1200Hz) for progress
+
+### Review Mode
+- **Basic navigation**: `Keypad 7/8/9` (lines), `Keypad 4/5/6` (words), `Keypad 1/2/3` (characters)
+- **Exit review**: `Fenrir + Keypad .`
+- **Screen reading**: `Fenrir + Keypad 5` (current screen)
+
+## Configuration
+
+To change keyboard layout, edit `/etc/fenrir/settings/settings.conf`:
+
+```ini
+[keyboard]
+keyboardLayout=desktop  # or laptop, nvda-desktop, nvda-laptop, pty, pty2
+```
+
+## Available Key Constants
+
 Keymap for Fenrir
 KEY_RESERVED
 KEY_ESC

config/keyboard/desktop.conf

@@ -74,7 +74,7 @@ KEY_FENRIR,KEY_0=bookmark_10
 KEY_FENRIR,KEY_KPSLASH=set_window_application
 2,KEY_FENRIR,KEY_KPSLASH=clear_window_application
 KEY_KPPLUS=progress_bar_monitor
-KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
+#KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
 KEY_FENRIR,KEY_F2=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech
@@ -114,6 +114,8 @@ KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_X=remove_marks
 KEY_FENRIR,KEY_X=set_mark
 KEY_FENRIR,KEY_SHIFT,KEY_X=marked_text
 KEY_FENRIR,KEY_F10=toggle_vmenu_mode
+KEY_FENRIR,KEY_SHIFT,KEY_F10=voice_browser_safe
+KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_F10=apply_tested_voice
 KEY_FENRIR,KEY_SPACE=current_quick_menu_entry
 KEY_FENRIR,KEY_CTRL,KEY_SPACE=current_quick_menu_value
 KEY_FENRIR,KEY_RIGHT=next_quick_menu_entry

config/keyboard/laptop.conf

@@ -75,12 +75,12 @@ KEY_FENRIR,KEY_F2=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech
 KEY_FENRIR,KEY_ENTER=temp_disable_speech
-KEY_FENRIR,KEY_SHIFT,KEY_ENTER=silence_until_prompt
+KEY_FENRIR,KEY_SHIFT,KEY_P=progress_bar_monitor
+KEY_FENRIR,KEY_SHIFT,KEY_ENTER=toggle_auto_read
 KEY_FENRIR,KEY_SHIFT,KEY_CTRL,KEY_P=toggle_punctuation_level
 KEY_FENRIR,KEY_RIGHTBRACE=toggle_auto_spell_check
 KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_ENTER=toggle_output
 KEY_FENRIR,KEY_SHIFT,KEY_E=toggle_emoticons
-KEY_FENRIR,KEY_ENTER=toggle_auto_read
 KEY_FENRIR,KEY_CTRL,KEY_T=toggle_auto_time
 KEY_FENRIR,KEY_Y=toggle_highlight_tracking
 #=toggle_barrier
@@ -112,6 +112,8 @@ KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_X=remove_marks
 KEY_FENRIR,KEY_X=set_mark
 KEY_FENRIR,KEY_SHIFT,KEY_X=marked_text
 KEY_FENRIR,KEY_F10=toggle_vmenu_mode
+KEY_FENRIR,KEY_SHIFT,KEY_F10=voice_browser_safe
+KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_F10=apply_tested_voice
 KEY_FENRIR,KEY_SPACE=current_quick_menu_entry
 KEY_FENRIR,KEY_CTRL,KEY_SPACE=current_quick_menu_value
 KEY_FENRIR,KEY_RIGHT=next_quick_menu_entry

config/settings/settings.conf

@@ -95,7 +95,7 @@ fenrirMaxRate=450
 driver=vcsaDriver
 encoding=auto
 screenUpdateDelay=0.05
-ignoreScreen=
+ignoreScreen=7
 autodetectIgnoreScreen=True
 
 [keyboard]
@@ -124,7 +124,9 @@ interruptOnKeyPressFilter=
 doubleTapTimeout=0.2
 
 [general]
-debugLevel=0
+# Debug levels: 0=DEACTIVE, 1=ERROR, 2=WARNING, 3=INFO (most verbose)
+# For production use, WARNING (2) provides good balance of useful info without spam
+debugLevel=2
 # debugMode sets where the debug output should send to:
 # debugMode=File writes to debugFile (Default:/tmp/fenrir-PID.log)
 # debugMode=Print just prints on the screen
@@ -133,6 +135,9 @@ debugFile=
 punctuationProfile=default
 punctuationLevel=some
 respectPunctuationPause=True
+# Replace undefined punctuation with spaces instead of removing them
+# This improves readability of text with punctuation like [X]mute, IP addresses, etc.
+replaceUndefinedPunctuationWithSpace=True
 newLinePause=True
 numberOfClipboards=50
 # used path for "export_clipboard_to_file"
@@ -143,8 +148,8 @@ emoticons=True
 # define the current Fenrir key
 fenrirKeys=KEY_KP0,KEY_META,KEY_INSERT
 scriptKeys=KEY_COMPOSE
-timeFormat=%H:%M:%P
+timeFormat=%%I:%%M%%P
-dateFormat=%A, %B %d, %Y
+dateFormat=%%A, %%B %%d, %%Y
 autoSpellCheck=True
 spellCheckLanguage=en_US
 # path for your scripts "scriptKeys" functionality
@@ -218,16 +223,24 @@ quickMenu=speech#rate;speech#pitch;speech#volume
 # Custom prompt patterns for silence until prompt feature
 # You can add your own shell prompt patterns as regular expressions
 # Each pattern should be on a separate line, format: customPatterns=pattern1,pattern2,pattern3
-# Examples:
+# 
+# Built-in patterns include:
+# - Shell prompts: $, #, >, user@host$, [user@host]$, bash-5.1$
+# - Package manager prompts: [Y/n], [y/N], [Yes/No], (Y/n), (y/N)
+# - sudo prompts: [sudo] password for user:, Password:, user's password:
+# - Confirmation prompts: Press any key, Are you sure?, Please confirm
+#
+# Custom pattern examples:
 # For PS1='[\u@\h \W] \$ ' use: \[.*@.*\s.*\]\s*[$#>]\s*
 # For "[user@hostname ~] $" use: \[.*@.*\s.*\]\s*[$#>]\s*
 # For custom prompts ending with specific strings, use patterns like: .*your_prompt_ending$
+# For custom package manager prompts: .*your_package_manager.*\[[YyNn]/[YyNn]\].*
 customPatterns=
 
 # Specific prompt strings to match exactly (useful for very specific custom prompts)
 # Format: exactMatches=prompt1,prompt2,prompt3
 # Examples:
-# exactMatches=[storm@fenrir ~] $,[root@fenrir ~] #
+# exactMatches=[storm@fenrir ~] $,[root@fenrir ~] #,Continue installation? [Y/n]
 exactMatches=
 
 [time]

config/sound/default/soundicons.conf

@@ -30,9 +30,6 @@ ContentChanged='ContentChanged.wav'
 # Speech has turned On or Off
 SpeechOn='SpeechOn.wav'
 SpeechOff='SpeechOff.wav'
-# Braille has turned On or Off
-BrailleOn='BrailleOn.wav'
-BrailleOff='BrailleOff.wav'
 # SoundIcons has turned On or Off
 SoundOn='SoundOn.wav'
 SoundOff='SoundOff.wav'
@@ -44,9 +41,8 @@ PlaceEndMark='PlaceEndMark.wav'
 CopyToClipboard='CopyToClipboard.wav'
 # Pasted on the screen
 PasteClipboardOnScreen='PasteClipboardOnScreen.wav'
-# An error accoured while speech or braille output or reading the screen
+# An error accoured while speech output or reading the screen
 ErrorSpeech='ErrorSpeech.wav'
-ErrorBraille='ErrorBraille.wav'
 ErrorScreen='ErrorScreen.wav'
 # If you cursor over an text that has attributs (like color)
 HasAttributes='has_attribute.wav'

docs/user.md

@@ -50,6 +50,12 @@ Navigate the screen without moving the text cursor. Essential for examining cont
 - `Keypad 1/3` - Previous/next character
 - `Fenrir + Keypad dot` - Exit review mode
 
+### Table Navigation
+- `Fenrir + Keypad *` - Toggle table mode / highlight tracking
+- `Keypad 4/6` - Previous/next column (in table mode)
+- `Fenrir + Keypad 4/6` - First/last column (in table mode)
+- `Fenrir + X` - Set column headers (in table mode)
+
 ### Information
 - `Fenrir + T` - Announce time
 - `Fenrir + T T` - Announce date
@@ -240,6 +246,47 @@ send_fenrir_command("command say Process complete")
 
 ## Advanced Features
 
+### Table Navigation Mode
+
+Fenrir includes advanced table navigation capabilities for working with tabular data in terminal applications, CSV files, and formatted text output.
+
+#### Entering Table Mode
+1. Press `Fenrir + Keypad *` (desktop) or `Fenrir + Y` (laptop)
+2. Cycle through: Highlight tracking → Cursor tracking → Table mode
+3. Listen for "table mode enabled" announcement
+
+#### Table Navigation Commands
+- **Column navigation**: `Keypad 4/6` - Move between columns
+- **Row boundaries**: `Fenrir + Keypad 4/6` - Jump to first/last column
+- **Cell characters**: `Fenrir + Keypad 1/3` - First/last character in cell
+- **Set headers**: `Fenrir + X` - Mark current line as column headers
+
+#### Table Features
+- **Automatic detection**: Supports CSV, pipe-separated, space-aligned columns
+- **Column headers**: Set and announce headers for better context
+- **Boundary feedback**: Audio cues when reaching row boundaries
+- **Cell-by-cell navigation**: Precise positioning within tables
+
+### Progress Bar Monitoring
+
+Fenrir automatically detects and provides audio feedback for progress indicators.
+
+#### Progress Detection
+- **Percentage**: 45%, 67.5%, 100%
+- **Fractions**: 15/100, 3 of 10, Step 7/15
+- **Progress bars**: [####    ], [====>   ]
+- **Activity indicators**: Loading..., Processing...
+
+#### Audio Feedback
+- **Progress tones**: Ascending 400Hz-1200Hz frequency range
+- **Activity beeps**: 800Hz tone every 2 seconds
+- **Non-intrusive**: Doesn't interrupt speech or other audio
+
+#### Usage
+- **Enable**: Use `progress_bar_monitor` command (assign key binding)
+- **Automatic**: Works with downloads, compilations, installations
+- **Remote control**: Enable via socket commands
+
 ### Spell Checking
 - `Fenrir + S` - Spell check current word
 - `Fenrir + S S` - Add word to dictionary

requirements.txt

@@ -1,4 +1,5 @@
 daemonize
+dbus-python
 evdev
 pexpect
 pyenchant

setup.py

@@ -37,7 +37,7 @@ for directory in directories:
         if not forceSettingsFlag:
             try:
                 files = [f for f in files if not f.endswith('settings.conf')]
-            except:
+            except Exception as e:
                 pass
     elif 'config/scripts' in directory:
         destDir = '/usr/share/fenrirscreenreader/scripts'

src/fenrir

@@ -4,19 +4,22 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributors.
 
+import argparse
+import inspect
 import os
 import sys
-import inspect
+
-import argparse
 from daemonize import Daemonize
 
+from fenrirscreenreader import fenrirVersion
+from fenrirscreenreader.core import fenrirManager
+
 # Get the fenrir installation path
-fenrirPath = os.path.dirname(os.path.realpath(os.path.abspath(inspect.getfile(inspect.currentframe()))))
+fenrirPath = os.path.dirname(os.path.realpath(
-if not fenrirPath in sys.path:
+    os.path.abspath(inspect.getfile(inspect.currentframe()))))
+if fenrirPath not in sys.path:
     sys.path.append(fenrirPath)
 
-from fenrirscreenreader.core import fenrirManager
-from fenrirscreenreader import fenrirVersion
 
 def create_argument_parser():
     """Create and return the argument parser for Fenrir"""
@@ -27,7 +30,7 @@ def create_argument_parser():
     argumentParser.add_argument(
         '-v', '--version',
         action='version',
-        version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}',
+        version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.code_name}',
         help='Show version information and exit'
     )
     argumentParser.add_argument(
@@ -68,10 +71,10 @@ def create_argument_parser():
         help='Use PTY emulation with evdev for input (single instance)'
     )
     argumentParser.add_argument(
-        '-F', '--force-all-screens',
+        '-F',
+        '--force-all-screens',
         action='store_true',
-        help='Force Fenrir to respond on all screens, ignoring ignoreScreen setting'
+        help='Force Fenrir to respond on all screens, ignoring ignoreScreen setting')
-    )
     argumentParser.add_argument(
         '-i', '-I', '--ignore-screen',
         metavar='SCREEN',
@@ -80,29 +83,52 @@ def create_argument_parser():
     )
     return argumentParser
 
+
 def validate_arguments(cliArgs):
     """Validate command line arguments"""
     if cliArgs.options:
         for option in cliArgs.options.split(';'):
             if option and ('#' not in option or '=' not in option):
                 return False, f"Invalid option format: {option}\nExpected format: SECTION#SETTING=VALUE"
-    
+
     if cliArgs.emulated_pty and cliArgs.emulated_evdev:
         return False, "Cannot use both --emulated-pty and --emulated-evdev simultaneously"
-    
+
     return True, None
 
+
 def run_fenrir():
     """Main function that runs Fenrir"""
-    fenrirApp = fenrirManager.fenrirManager(cliArgs)
+    fenrirApp = None
-    fenrirApp.proceed()
+    try:
-    del fenrirApp
+        fenrirApp = fenrirManager.FenrirManager(cliArgs)
+        fenrirApp.proceed()
+    except Exception as e:
+        print(f"Error starting Fenrir: {e}", file=sys.stderr)
+        if fenrirApp and hasattr(fenrirApp, 'cleanup_on_error'):
+            try:
+                fenrirApp.cleanup_on_error()
+            except Exception as cleanup_error:
+                print(
+                    f"Error during cleanup: {cleanup_error}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        if fenrirApp:
+            del fenrirApp
+        # Clean up PID file if it exists
+        pidFile = "/run/fenrir.pid"
+        if os.path.exists(pidFile):
+            try:
+                os.remove(pidFile)
+            except Exception:
+                pass
+
 
 def main():
     global cliArgs
     argumentParser = create_argument_parser()
     cliArgs = argumentParser.parse_args()
-    
+
     # Validate arguments
     isValid, errorMsg = validate_arguments(cliArgs)
     if not isValid:
@@ -123,5 +149,6 @@ def main():
         )
         daemonProcess.start()
 
+
 if __name__ == "__main__":
     main()

src/fenrirscreenreader/commands/command_template.py

@@ -2,20 +2,27 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return 'No description found'         
+    def get_description(self):
+        return "No description found"
+
     def run(self):
         pass
-    def setCallback(self, callback):
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/00_init_commands.py

@@ -2,25 +2,38 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
 # this command is just to initialize stuff.
-# like init index lists in memoryManager
+# like init index lists in MemoryManager
 # it is not useful to execute it
-class command():
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
         # clipboard
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env["runtime"]["MemoryManager"].add_index_list(
+            "clipboardHistory",
+            self.env["runtime"]["SettingsManager"].get_setting_as_int(
+                "general", "numberOfClipboards"
+            ),
+        )
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return 'No description found'         
+    def get_description(self):
+        return "No description found"
+
     def run(self):
         pass
-    def setCallback(self, callback):
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/add_word_to_spell_check.py

@@ -2,53 +2,92 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import word_utils
 import string
+
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import word_utils
+
 initialized = False
 try:
     import enchant
+
     initialized = True
-except:
+except Exception as e:
     pass
-    
+
-class command():
+
+class command:
     def __init__(self):
-        self.language = ''
+        self.language = ""
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
-        self.updateSpellLanguage()
+        self.update_spell_language()
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('adds the current word to the exceptions dictionary')        
+    def get_description(self):
-    def updateSpellLanguage(self):  
+        return _("adds the current word to the exceptions dictionary")
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
+
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
+    def update_spell_language(self):
-    
+        self.spellChecker = enchant.Dict(
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+        )
+        self.language = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "spellCheckLanguage"
+        )
+
     def run(self):
         if not initialized:
-           return
+            return
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+        if (
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+            != self.language
+        ):
             try:
-                self.updateSpellLanguage()
+                self.update_spell_language()
             except Exception as e:
-                return    
+                return
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
+        new_content = self.env["screen"]["new_content_text"].split("\n")[
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)
+            cursor_pos["y"]
-        currWord = currWord.strip(string.whitespace + r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~')
+        ]
+        x, y, curr_word, end_of_screen, line_break = (
+            word_utils.get_current_word(cursor_pos["x"], 0, new_content)
+        )
+        curr_word = curr_word.strip(
+            string.whitespace + r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~'
+        )
 
-        if currWord != '':
+        if curr_word != "":
-            if self.spellChecker.is_added(currWord):
+            if self.spellChecker.is_added(curr_word):
-                self.env['runtime']['outputManager'].presentText(_('{0} is already in dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} is already in dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Cancel",
+                    interrupt=True,
+                )
             else:
-                self.spellChecker.add(currWord)             
+                self.spellChecker.add(curr_word)
-                self.env['runtime']['outputManager'].presentText(_('{0} added to dictionary').format(currWord,), soundIcon='Accept', interrupt=True)               
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} added to dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Accept",
+                    interrupt=True,
+                )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/adjustment_base.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributors.
+
+import math
+
+from fenrirscreenreader.core.i18n import _
+
+
+class adjustment_command:
+    """Base class for speech and sound adjustment commands"""
+
+    def __init__(self, section, setting, direction, step=0.1):
+        self.section = section  # 'speech' or 'sound'
+        self.setting = setting  # 'rate', 'pitch', 'volume'
+        self.direction = direction  # 'inc' or 'dec'
+        self.step = step
+
+    def initialize(self, environment):
+        self.env = environment
+
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        action = "Increase" if self.direction == "inc" else "Decrease"
+        if self.section == "speech":
+            return _(f"{action} the speech {self.setting}")
+        else:
+            return _(f"{action} the {self.section} {self.setting}")
+
+    def run(self):
+        if self.section == "sound" and self.setting == "volume":
+            # Sound volume uses different method
+            self._adjust_sound_volume()
+        else:
+            # Speech rate, pitch, volume use standard method
+            self._adjust_speech_setting()
+
+    def _adjust_speech_setting(self):
+        """Adjust speech settings (rate, pitch, volume)"""
+        value = self.env["runtime"]["SettingsManager"].get_setting_as_float(
+            self.section, self.setting
+        )
+
+        # Apply adjustment with rounding
+        if self.direction == "inc":
+            value = round((math.ceil(10 * value) / 10) + self.step, 2)
+            if value > 1.0:
+                value = 1.0
+        else:  # dec
+            value = round((math.ceil(10 * value) / 10) - self.step, 2)
+            if value < 0.0:
+                value = 0.0
+
+        # Set the new value
+        self.env["runtime"]["SettingsManager"].set_setting(
+            self.section, self.setting, str(value)
+        )
+
+        # Present feedback
+        percentage = int(value * 100)
+        if self.section == "speech":
+            feedback = _("{0} percent speech {1}").format(
+                percentage, self.setting
+            )
+        else:
+            feedback = _("{0} percent {1} {2}").format(
+                percentage, self.section, self.setting
+            )
+
+        self.env["runtime"]["OutputManager"].present_text(
+            feedback, sound_icon="", interrupt=True
+        )
+
+    def _adjust_sound_volume(self):
+        """Adjust sound volume using same logic as speech"""
+        value = self.env["runtime"]["SettingsManager"].get_setting_as_float(
+            self.section, self.setting
+        )
+
+        # Sound volume uses same math as speech settings
+        if self.direction == "inc":
+            value = round((math.ceil(10 * value) / 10) + self.step, 2)
+            if value > 1.0:
+                value = 1.0
+        else:  # dec
+            value = round((math.ceil(10 * value) / 10) - self.step, 2)
+            if value < 0.0:
+                value = 0.0
+
+        # Set the new value
+        self.env["runtime"]["SettingsManager"].set_setting(
+            self.section, self.setting, str(value)
+        )
+
+        # Present feedback with appropriate sound icon
+        percentage = int(value * 100)
+        sound_icon = "SoundOn" if self.direction == "inc" else "SoundOff"
+        feedback = _("{0} percent sound volume").format(percentage)
+        self.env["runtime"]["OutputManager"].present_text(
+            feedback, sound_icon=sound_icon, interrupt=True
+        )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/announce_fenrir_version.py

@@ -2,26 +2,37 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 from fenrirscreenreader import fenrirVersion
+from fenrirscreenreader.core.i18n import _
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('Present the version of Fenrir currrrently in use.')
+    def get_description(self):
-    
+        return _("Present the version of Fenrir currently in use.")
+
     def run(self):
         try:
-            self.env['runtime']['outputManager'].presentText(f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
-        except exception as e:
+                f"Fenrir screen reader version {
-            self.env['runtime']['outputManager'].presentText(_('Version information is unavailable.'), interrupt=True)
+                    fenrirVersion.version}-{
-            
+                    fenrirVersion.code_name}",
-    def setCallback(self, callback):
+                interrupt=True,
+            )
+        except Exception as e:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Version information is unavailable."), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/apply_tested_voice.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
+    def __init__(self):
+        pass
+
+    def initialize(self, environment):
+        self.env = environment
+
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return "Apply the last tested voice from safe voice browser"
+
+    def run(self):
+        try:
+            # Check if we have a tested voice
+            if (
+                "commandBuffer" not in self.env
+                or "lastTestedModule" not in self.env["commandBuffer"]
+                or "lastTestedVoice" not in self.env["commandBuffer"]
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    "No voice has been tested yet", interrupt=True
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    "Use voice browser first", interrupt=True
+                )
+                return
+
+            module = self.env["commandBuffer"]["lastTestedModule"]
+            voice = self.env["commandBuffer"]["lastTestedVoice"]
+
+            self.env["runtime"]["OutputManager"].present_text(
+                f"Applying {voice} from {module}", interrupt=True
+            )
+
+            # Apply to runtime settings only (temporary until saved)
+            SettingsManager = self.env["runtime"]["SettingsManager"]
+
+            # Store old values for safety
+            old_driver = SettingsManager.get_setting("speech", "driver")
+            old_module = SettingsManager.get_setting("speech", "module")
+            old_voice = SettingsManager.get_setting("speech", "voice")
+
+            try:
+                # Apply new settings to runtime only (use set_setting to update
+                # settingArgDict)
+                SettingsManager.set_setting(
+                    "speech", "driver", "speechdDriver"
+                )
+                SettingsManager.set_setting("speech", "module", module)
+                SettingsManager.set_setting("speech", "voice", voice)
+
+                # Apply to speech driver instance directly
+                if "SpeechDriver" in self.env["runtime"]:
+                    SpeechDriver = self.env["runtime"]["SpeechDriver"]
+
+                    # Set the module and voice on the driver instance
+                    SpeechDriver.set_module(module)
+                    SpeechDriver.set_voice(voice)
+
+                    self.env["runtime"]["OutputManager"].present_text(
+                        "Voice applied successfully!", interrupt=True
+                    )
+                    self.env["runtime"]["OutputManager"].present_text(
+                        "Use save settings to make permanent", interrupt=True
+                    )
+                    self.env["runtime"]["OutputManager"].play_sound("Accept")
+
+            except Exception as e:
+                # Revert on failure
+                SettingsManager.set_setting("speech", "driver", old_driver)
+                SettingsManager.set_setting("speech", "module", old_module)
+                SettingsManager.set_setting("speech", "voice", old_voice)
+
+                self.env["runtime"]["OutputManager"].present_text(
+                    f"Failed to apply voice, reverted: {str(e)}",
+                    interrupt=True,
+                )
+                self.env["runtime"]["OutputManager"].play_sound("Error")
+
+        except Exception as e:
+            self.env["runtime"]["OutputManager"].present_text(
+                f"Apply voice error: {str(e)}", interrupt=True
+            )
+            self.env["runtime"]["OutputManager"].play_sound("Error")
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/attribute_cursor.py

@@ -2,29 +2,45 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import screen_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('Reads attributes of current cursor position')         
+    def get_description(self):
+        return _("Reads attributes of current cursor position")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
         try:
-            attributes = self.env['runtime']['attributeManager'].getAttributeByXY( cursorPos['x'], cursorPos['y'])
+            attributes = self.env["runtime"][
+                "AttributeManager"
+            ].get_attribute_by_xy(cursor_pos["x"], cursor_pos["y"])
         except Exception as e:
-            print(e)        
+            print(e)
-        attributeFormatString = self.env['runtime']['settingsManager'].getSetting('general', 'attributeFormatString')
+        attribute_format_string = self.env["runtime"][
-        attributeFormatString = self.env['runtime']['attributeManager'].formatAttributes(attributes, attributeFormatString)
+            "SettingsManager"
-        
+        ].get_setting("general", "attribute_format_string")
-        self.env['runtime']['outputManager'].presentText(attributeFormatString, soundIcon='', interrupt=True)
+        attribute_format_string = self.env["runtime"][
-    def setCallback(self, callback):
+            "AttributeManager"
+        ].format_attributes(attributes, attribute_format_string)
+
+        self.env["runtime"]["OutputManager"].present_text(
+            attribute_format_string, sound_icon="", interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/bookmark_1.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '1'
+        super().__init__(1, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_10.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '10'
+        super().__init__(10, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_2.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '2'
+        super().__init__(2, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_3.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '3'
+        super().__init__(3, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_4.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '4'
+        super().__init__(4, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_5.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '5'
+        super().__init__(5, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_6.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '6'
+        super().__init__(6, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_7.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '7'
+        super().__init__(7, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_8.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '8'
+        super().__init__(8, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_9.py

@@ -2,47 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-from fenrirscreenreader.utils import mark_utils
+import os
-from fenrirscreenreader.utils import line_utils
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '9'
+        super().__init__(9, "read")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/bookmark_base.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributors.
+
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.utils import mark_utils
+
+
+class bookmark_command:
+    """Base class for bookmark operations - read, set, clear"""
+
+    def __init__(self, bookmark_id, action="read"):
+        self.ID = str(bookmark_id)
+        self.action = action
+
+    def initialize(self, environment):
+        self.env = environment
+        # Always initialize bookmark structure - all commands need this
+        if self.ID not in self.env["commandBuffer"]["bookMarks"]:
+            self.env["commandBuffer"]["bookMarks"][self.ID] = {}
+
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        if self.action == "read":
+            return _("read Bookmark {0}").format(self.ID)
+        elif self.action == "set":
+            return _("set Bookmark {0}").format(self.ID)
+        elif self.action == "clear":
+            return _("remove Bookmark {0}").format(self.ID)
+        return f"{self.action} Bookmark {self.ID}"
+
+    def run(self):
+        if self.action == "read":
+            self._read_bookmark()
+        elif self.action == "set":
+            self._set_bookmark()
+        elif self.action == "clear":
+            self._clear_bookmark()
+
+    def _read_bookmark(self):
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+
+        if not self.env["commandBuffer"]["bookMarks"][self.ID]:
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark {0} not set".format(self.ID), interrupt=True
+            )
+            return
+
+        if curr_app not in self.env["commandBuffer"]["bookMarks"][self.ID]:
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark for application {0} not set".format(curr_app),
+                interrupt=True,
+            )
+            return
+
+        if not self.env["commandBuffer"]["bookMarks"][self.ID][curr_app].get(
+            "1"
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                "Bookmark for application {0} not set".format(curr_app),
+                interrupt=True,
+            )
+            return
+
+        # Get bookmarked text
+        marked = ""
+        start_mark = self.env["commandBuffer"]["bookMarks"][self.ID][curr_app][
+            "1"
+        ].copy()
+
+        if self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]["2"]:
+            end_mark = self.env["commandBuffer"]["bookMarks"][self.ID][
+                curr_app
+            ]["2"].copy()
+            marked = mark_utils.get_text_between_marks(
+                start_mark, end_mark, self.env["screen"]["new_content_text"]
+            )
+        else:
+            x, y, marked = line_utils.get_current_line(
+                start_mark["x"],
+                start_mark["y"],
+                self.env["screen"]["new_content_text"],
+            )
+
+        if marked.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                marked, interrupt=True
+            )
+
+    def _set_bookmark(self):
+        if not self.env["commandBuffer"]["Marks"]["1"]:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("No mark found"), interrupt=True
+            )
+            return
+
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+        self.env["commandBuffer"]["bookMarks"][self.ID][curr_app] = {}
+
+        bookmarks = self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]
+        bookmarks["1"] = self.env["commandBuffer"]["Marks"]["1"].copy()
+
+        if self.env["commandBuffer"]["Marks"]["2"]:
+            bookmarks["2"] = self.env["commandBuffer"]["Marks"]["2"].copy()
+        else:
+            bookmarks["2"] = None
+
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Bookmark {0} set for application {1}").format(
+                self.ID, curr_app
+            ),
+            interrupt=True,
+        )
+
+        # Clear marks after setting bookmark
+        self.env["commandBuffer"]["Marks"]["1"] = None
+        self.env["commandBuffer"]["Marks"]["2"] = None
+
+    def _clear_bookmark(self):
+        curr_app = self.env["runtime"][
+            "ApplicationManager"
+        ].get_current_application()
+
+        bookmarks = self.env["commandBuffer"]["bookMarks"]
+        if self.ID in bookmarks and curr_app in bookmarks[self.ID]:
+            del self.env["commandBuffer"]["bookMarks"][self.ID][curr_app]
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Bookmark {0} removed for application {1}").format(
+                    self.ID, curr_app
+                ),
+                interrupt=True,
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Bookmark {0} not set for application {1}").format(
+                    self.ID, curr_app
+                ),
+                interrupt=True,
+            )
+
+    def set_callback(self, callback):
+        pass
+
+
+# Factory function to create bookmark command instances
+
+
+def create_bookmark_commands():
+    """Create all bookmark command instances"""
+    commands = {}
+
+    # Create read bookmark commands (bookmark_1 through bookmark_10)
+    for i in range(1, 11):
+        commands[f"bookmark_{i}"] = lambda i=i: bookmark_command(i, "read")
+
+    # Create set bookmark commands (set_bookmark_1 through set_bookmark_10)
+    for i in range(1, 11):
+        commands[f"set_bookmark_{i}"] = lambda i=i: bookmark_command(i, "set")
+
+    # Create clear bookmark commands (clear_bookmark_1 through
+    # clear_bookmark_10)
+    for i in range(1, 11):
+        commands[f"clear_bookmark_{i}"] = lambda i=i: bookmark_command(
+            i, "clear"
+        )
+
+    return commands
+
+
+# For backwards compatibility, provide individual command classes
+# This allows the existing command loading system to work unchanged
+
+
+def _make_command_class(bookmark_id, action):
+    """Create a command class for a specific bookmark and action"""
+
+    class command(bookmark_command):
+        def __init__(self):
+            super().__init__(bookmark_id, action)
+
+    return command
+
+
+# Generate individual command classes for each bookmark operation
+# These will be used by the existing command loading system
+
+
+# Read bookmarks (bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f"bookmark_{i}_command"] = _make_command_class(i, "read")
+
+# Set bookmarks (set_bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f"set_bookmark_{i}_command"] = _make_command_class(i, "set")
+
+# Clear bookmarks (clear_bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f"clear_bookmark_{i}_command"] = _make_command_class(i, "clear")

src/fenrirscreenreader/commands/commands/clear_bookmark_1.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '1'
+        super().__init__(1, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_10.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '10'
+        super().__init__(10, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_2.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '2'
+        super().__init__(2, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_3.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '3'
+        super().__init__(3, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_4.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '4'
+        super().__init__(4, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_5.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '5'
+        super().__init__(5, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_6.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '6'
+        super().__init__(6, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_7.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '7'
+        super().__init__(7, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_8.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '8'
+        super().__init__(8, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_bookmark_9.py

@@ -2,26 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "bookmark_base.py")
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+bookmark_command = _module.bookmark_command
+
+
+class command(bookmark_command):
     def __init__(self):
-        self.ID = '9'
+        super().__init__(9, "clear")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/clear_clipboard.py

@@ -2,23 +2,33 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('clears the currently selected clipboard')     
+    def get_description(self):
+        return _("clears the currently selected clipboard")
 
     def run(self):
-        self.env['runtime']['memoryManager'].clearCurrentIndexList('clipboardHistory')
+        self.env["runtime"]["MemoryManager"].clear_current_index_list(
-        self.env['runtime']['outputManager'].presentText(_('clipboard cleared'), interrupt=True)
+            "clipboardHistory"
-        return                
+        )
-    def setCallback(self, callback):
+        self.env["runtime"]["OutputManager"].present_text(
+            _("clipboard cleared"), interrupt=True
+        )
+        return
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/clear_window_application.py

@@ -2,26 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Turn off window mode for application')
+    def get_description(self):
-    
+        return _("Turn off window mode for application")
-    def run(self):
+
-        if self.env['runtime']['cursorManager'].clearWindowForApplication():
+    def run(self):
-            currApp = self.env['runtime']['applicationManager'].getCurrentApplication()    
+        if self.env["runtime"]["CursorManager"].clear_window_for_application():
-            self.env['runtime']['outputManager'].presentText(_('Window Mode off for application {0}').format(currApp,), interrupt=True)
+            curr_app = self.env["runtime"][
-        else:
+                "ApplicationManager"
-            self.env['runtime']['outputManager'].presentText(_("Not in window Mode"), interrupt=True)
+            ].get_current_application()
-        
+            self.env["runtime"]["OutputManager"].present_text(
-    def setCallback(self, callback):
+                _("Window Mode off for application {0}").format(
+                    curr_app,
+                ),
+                interrupt=True,
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Not in window Mode"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_last_echo_to_clipboard.py

@@ -2,27 +2,35 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('copies last presented text to the clipboard')    
-    
-    def run(self):
-        lastEcho = self.env['runtime']['outputManager'].getLastEcho()
-        if lastEcho.rstrip() != "":
-            lastEcho = lastEcho.rstrip()
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', lastEcho)
-        self.env['runtime']['outputManager'].presentText(lastEcho, soundIcon='CopyToClipboard', interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("copies last presented text to the clipboard")
+
+    def run(self):
+        last_echo = self.env["runtime"]["OutputManager"].get_last_echo()
+        if last_echo.rstrip() != "":
+            last_echo = last_echo.rstrip()
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", last_echo
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            last_echo, sound_icon="CopyToClipboard", interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_marked_to_clipboard.py

@@ -2,73 +2,81 @@
 # -*- coding: utf-8 -*-
 
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
-class command():
+
+
+class command:
     def __init__(self):
         pass
-        
+
     def initialize(self, environment):
         self.env = environment
-        
+
     def shutdown(self):
-        pass 
+        pass
-        
+
-    def getDescription(self):
+    def get_description(self):
-        return _('copies marked text to the currently selected clipboard')    
+        return _("copies marked text to the currently selected clipboard")
-    
+
-    def getTextFromScreen(self, startMark, endMark):
+    def get_text_from_screen(self, start_mark, end_mark):
-        screenContent = self.env['screen']['newContentText']
+        screen_content = self.env["screen"]["new_content_text"]
-        screenLines = screenContent.split('\n')
+        screen_lines = screen_content.split("\n")
-        
+
-        startY = min(startMark['y'], len(screenLines) - 1)
+        start_y = min(start_mark["y"], len(screen_lines) - 1)
-        endY = min(endMark['y'], len(screenLines) - 1)
+        end_y = min(end_mark["y"], len(screen_lines) - 1)
-        
+
         # If marks are on the same line
-        if startY == endY:
+        if start_y == end_y:
-            line = screenLines[startY]
+            line = screen_lines[start_y]
-            startX = min(startMark['x'], len(line))
+            start_x = min(start_mark["x"], len(line))
-            endX = min(endMark['x'], len(line)) + 1
+            end_x = min(end_mark["x"], len(line)) + 1
-            return line[startX:endX]
+            return line[start_x:end_x]
-            
+
         # Handle multi-line selection
         result = []
-        
+
         # First line (from start mark to end of line)
-        firstLine = screenLines[startY]
+        first_line = screen_lines[start_y]
-        startX = min(startMark['x'], len(firstLine))
+        start_x = min(start_mark["x"], len(first_line))
-        result.append(firstLine[startX:].rstrip())
+        result.append(first_line[start_x:].rstrip())
-        
+
         # Middle lines (complete lines)
-        for lineNum in range(startY + 1, endY):
+        for lineNum in range(start_y + 1, end_y):
-            result.append(screenLines[lineNum].rstrip())
+            result.append(screen_lines[lineNum].rstrip())
-            
+
         # Last line (from start to end mark)
-        if endY > startY:
+        if end_y > start_y:
-            lastLine = screenLines[endY]
+            last_line = screen_lines[end_y]
-            endX = min(endMark['x'], len(lastLine)) + 1
+            end_x = min(end_mark["x"], len(last_line)) + 1
-            result.append(lastLine[:endX].rstrip())
+            result.append(last_line[:end_x].rstrip())
-            
+
-        return '\n'.join(result)
+        return "\n".join(result)
-    
+
     def run(self):
-        if not self.env['commandBuffer']['Marks']['1']:
+        if not self.env["commandBuffer"]["Marks"]["1"]:
-            self.env['runtime']['outputManager'].presentText(_("One or two marks are needed"), interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("One or two marks are needed"), interrupt=True
+            )
             return
-        if not self.env['commandBuffer']['Marks']['2']:
+        if not self.env["commandBuffer"]["Marks"]["2"]:
-            self.env['runtime']['cursorManager'].setMark()
+            self.env["runtime"]["CursorManager"].set_mark()
-            
+
         # use the last first and the last setted mark as range
-        startMark = self.env['commandBuffer']['Marks']['1'].copy()
+        start_mark = self.env["commandBuffer"]["Marks"]["1"].copy()
-        endMark = self.env['commandBuffer']['Marks']['2'].copy()         
+        end_mark = self.env["commandBuffer"]["Marks"]["2"].copy()
-        
+
-        # Replace mark_utils.getTextBetweenMarks with our new method
+        # Replace mark_utils.get_text_between_marks with our new method
-        marked = self.getTextFromScreen(startMark, endMark)
+        marked = self.get_text_from_screen(start_mark, end_mark)
-        
+
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', marked)
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", marked
+        )
         # reset marks
-        self.env['runtime']['cursorManager'].clearMarks()      
+        self.env["runtime"]["CursorManager"].clear_marks()
-        self.env['runtime']['outputManager'].presentText(marked, soundIcon='CopyToClipboard', interrupt=True)
+        self.env["runtime"]["OutputManager"].present_text(
-        
+            marked, sound_icon="CopyToClipboard", interrupt=True
-    def setCallback(self, callback):
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_clipboard.py

@@ -2,26 +2,39 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('speaks the contents of the currently selected clipboard')       
+    def get_description(self):
+        return _("speaks the contents of the currently selected clipboard")
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+            "clipboardHistory"
-            return 
+        ):
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            self.env["runtime"]["OutputManager"].present_text(
-        self.env['runtime']['outputManager'].presentText(clipboard , interrupt=True)
+                _("clipboard empty"), interrupt=True
-               
+            )
-    def setCallback(self, callback):
+            return
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen.py

@@ -2,25 +2,34 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('reads the contents of the current screen')        
+    def get_description(self):
+        return _("reads the contents of the current screen")
 
     def run(self):
-        if self.env['screen']['newContentText'].isspace():
+        if self.env["screen"]["new_content_text"].isspace():
-            self.env['runtime']['outputManager'].presentText(_("screen is empty"), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
-        else:    
+                _("screen is empty"), sound_icon="EmptyLine", interrupt=True
-           self.env['runtime']['outputManager'].presentText(self.env['screen']['newContentText'],interrupt=True)
+            )
- 
+        else:
-    def setCallback(self, callback):
+            self.env["runtime"]["OutputManager"].present_text(
+                self.env["screen"]["new_content_text"], interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_after_cursor.py

@@ -2,31 +2,43 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('reads from the cursor to the bottom of the screen')        
+    def get_description(self):
+        return _("reads from the cursor to the bottom of the screen")
 
     def run(self):
         # Prefer review cursor over text cursor
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        textAfterCursor = mark_utils.getTextAfterMark(cursorPos, self.env['screen']['newContentText'])
+        text_after_cursor = mark_utils.get_text_after_mark(
+            cursor_pos, self.env["screen"]["new_content_text"]
+        )
 
-        if textAfterCursor.isspace():
+        if text_after_cursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(textAfterCursor, interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                text_after_cursor, interrupt=True
+            )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_before_cursor.py

@@ -2,35 +2,44 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Reads from the top of the screen to the cursor position')        
+    def get_description(self):
+        return _("Reads from the top of the screen to the cursor position")
 
     def run(self):
         # Prefer review cursor over text cursor
-        if self.env['screen']['newCursorReview']:
+        if self.env["screen"]["newCursorReview"]:
-            cursorPos = self.env['screen']['newCursorReview'].copy()
+            cursor_pos = self.env["screen"]["newCursorReview"].copy()
         else:
-            cursorPos = self.env['screen']['newCursor'].copy()
+            cursor_pos = self.env["screen"]["new_cursor"].copy()
 
-        textBeforeCursor = mark_utils.getTextBeforeMark(cursorPos, self.env['screen']['newContentText'])
+        text_before_cursor = mark_utils.get_text_before_mark(
+            cursor_pos, self.env["screen"]["new_content_text"]
+        )
 
-        if textBeforeCursor.isspace():
+        if text_before_cursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(textBeforeCursor, interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
-   
+                text_before_cursor, interrupt=True
-    def setCallback(self, callback):
+            )
+
+    def set_callback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/current_quick_menu_entry.py

@@ -2,25 +2,34 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get current quick menu entry')
+    def get_description(self):
-    def run(self):
+        return _("get current quick menu entry")
-        menu = ''
+
-        value = ''
+    def run(self):
-        menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
+        menu = ""
-        if menu != '':
+        value = ""
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+        menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
-            self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+        if menu != "":
-    def setCallback(self, callback):
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                menu + " " + value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/current_quick_menu_value.py

@@ -2,21 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get current quick menu value')
+    def get_description(self):
-    def run(self):
+        return _("get current quick menu value")
-        value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+
-        self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+    def run(self):
-    def setCallback(self, callback):
+        value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+        self.env["runtime"]["OutputManager"].present_text(
+            value, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_column.py

@@ -2,24 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('Column number for cursor')       
+    def get_description(self):
+        return _("Column number for cursor")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['x'] + 1) , interrupt=True)
+            "CursorManager"
-        self.env['runtime']['outputManager'].announceActiveCursor()
+        ].get_review_or_text_cursor()
-        self.env['runtime']['outputManager'].presentText(' column number' , interrupt=False)
+        self.env["runtime"]["OutputManager"].present_text(
-        
+            str(cursor_pos["x"] + 1), interrupt=True
-    def setCallback(self, callback):
+        )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            " column number", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_lineno.py

@@ -2,24 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('Line number for cursor')         
+    def get_description(self):
+        return _("Line number for cursor")
+
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['y'] + 1), interrupt=True)
+            "CursorManager"
-        self.env['runtime']['outputManager'].announceActiveCursor()
+        ].get_review_or_text_cursor()
-        self.env['runtime']['outputManager'].presentText(' line number' , interrupt=False)
+        self.env["runtime"]["OutputManager"].present_text(
-        
+            str(cursor_pos["y"] + 1), interrupt=True
-    def setCallback(self, callback):
+        )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            " line number", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_position.py

@@ -2,25 +2,39 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('displays the position of the review cursor')        
+    def get_description(self):
+        return _("displays the position of the review cursor")
 
     def run(self):
         # Prefer review cursor over text cursor
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        self.env['runtime']['outputManager'].presentText(_("line {0}, column {1}, Terminal {2}").format(cursorPos['y']+1, cursorPos['x']+1, self.env['screen']['newTTY']), interrupt=True)
+        self.env["runtime"]["OutputManager"].present_text(
-   
+            _("line {0}, column {1}, Terminal {2}").format(
-    def setCallback(self, callback):
+                cursor_pos["y"] + 1,
+                cursor_pos["x"] + 1,
+                self.env["screen"]["newTTY"],
+            ),
+            interrupt=True,
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_read_line_to_cursor.py

@@ -2,32 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read line to cursor pos, use review cursor if you are in review mode, otherwhise use text cursor')
-    
-    def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
+    def shutdown(self):
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine[:cursorPos['x']], interrupt=True) 
-        self.env['runtime']['outputManager'].announceActiveCursor()
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _(
+            "read line to cursor pos, use review cursor if you are in review mode, "
+            "otherwhise use text cursor"
+        )
+
+    def run(self):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line[: cursor_pos["x"]], interrupt=True
+            )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/cursor_read_to_end_of_line.py

@@ -2,32 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read to end of line, use review cursor if you are in review mode, otherwhise use text cursor')        
-    
-    def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
+    def shutdown(self):
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine[cursorPos['x']:], interrupt=True) 
-        self.env['runtime']['outputManager'].announceActiveCursor()
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _(
+            "read to end of line, use review cursor if you are in review mode, "
+            "otherwhise use text cursor"
+        )
+
+    def run(self):
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+
+        x, y, curr_line = line_utils.get_current_line(
+            cursor_pos["x"],
+            cursor_pos["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line[cursor_pos["x"] :], interrupt=True
+            )
+        self.env["runtime"]["OutputManager"].announce_active_cursor()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/cycle_keyboard_layout.py

@@ -2,60 +2,75 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import os
 
-class command():
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('cycles between available keyboard layouts')
+    def get_description(self):
-    
+        return _("cycles between available keyboard layouts")
-    def getAvailableLayouts(self):
+
+    def get_available_layouts(self):
         """Get list of available keyboard layout files"""
         layouts = []
-        
+
         # Check standard locations for keyboard layouts
-        settingsRoot = '/etc/fenrirscreenreader/'
+        settings_root = "/etc/fenrirscreenreader/"
-        if not os.path.exists(settingsRoot):
+        if not os.path.exists(settings_root):
             # Fallback to source directory
             import fenrirscreenreader
-            fenrirPath = os.path.dirname(fenrirscreenreader.__file__)
+
-            settingsRoot = fenrirPath + '/../../config/'
+            fenrir_path = os.path.dirname(fenrirscreenreader.__file__)
-        
+            settings_root = fenrir_path + "/../../config/"
-        keyboardPath = settingsRoot + 'keyboard/'
+
-        
+        keyboard_path = settings_root + "keyboard/"
-        if os.path.exists(keyboardPath):
+
-            for file in os.listdir(keyboardPath):
+        if os.path.exists(keyboard_path):
-                if file.endswith('.conf') and not file.startswith('__') and not file.lower().startswith('pty'):
+            for file in os.listdir(keyboard_path):
-                    layout_name = file.replace('.conf', '')
+                if (
+                    file.endswith(".conf")
+                    and not file.startswith("__")
+                    and not file.lower().startswith("pty")
+                ):
+                    layout_name = file.replace(".conf", "")
                     if layout_name not in layouts:
                         layouts.append(layout_name)
-        
+
         # Ensure we have at least basic layouts
         if not layouts:
-            layouts = ['desktop', 'laptop']
+            layouts = ["desktop", "laptop"]
         else:
             layouts.sort()
-            
+
         return layouts
-    
+
     def run(self):
-        current_layout = self.env['runtime']['settingsManager'].getSetting('keyboard', 'keyboardLayout')
+        current_layout = self.env["runtime"]["SettingsManager"].get_setting(
-        
+            "keyboard", "keyboardLayout"
+        )
+
         # Extract layout name from full path if needed
-        if '/' in current_layout:
+        if "/" in current_layout:
-            current_layout = os.path.basename(current_layout).replace('.conf', '')
+            current_layout = os.path.basename(current_layout).replace(
-            
+                ".conf", ""
+            )
+
         # Get available layouts
-        available_layouts = self.getAvailableLayouts()
+        available_layouts = self.get_available_layouts()
-        
+
         # Find next layout in cycle
         try:
             current_index = available_layouts.index(current_layout)
@@ -63,28 +78,28 @@ class command():
         except ValueError:
             # If current layout not found, start from beginning
             next_index = 0
-            
+
         next_layout = available_layouts[next_index]
-        
+
         # Update setting and reload shortcuts
-        self.env['runtime']['settingsManager'].setSetting('keyboard', 'keyboardLayout', next_layout)
+        self.env["runtime"]["SettingsManager"].set_setting(
-        
+            "keyboard", "keyboardLayout", next_layout
+        )
+
         # Reload shortcuts with new layout
         try:
-            self.env['runtime']['inputManager'].reloadShortcuts()
+            self.env["runtime"]["InputManager"].reload_shortcuts()
-            self.env['runtime']['outputManager'].presentText(
+            self.env["runtime"]["OutputManager"].present_text(
-                _('Switched to {} keyboard layout').format(next_layout), 
+                _("Switched to {} keyboard layout").format(next_layout),
-                interrupt=True
+                interrupt=True,
             )
         except Exception as e:
-            self.env['runtime']['debug'].writeDebugOut(
+            self.env["runtime"]["DebugManager"].write_debug_out(
-                "Error reloading shortcuts: " + str(e), 
+                "Error reloading shortcuts: " + str(e), debug.DebugLevel.ERROR
-                debug.debugLevel.ERROR
             )
-            self.env['runtime']['outputManager'].presentText(
+            self.env["runtime"]["OutputManager"].present_text(
-                _('Error switching keyboard layout'), 
+                _("Error switching keyboard layout"), interrupt=True
-                interrupt=True
             )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
-        pass
+        pass

src/fenrirscreenreader/commands/commands/date.py

@@ -2,29 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import datetime
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('presents the date')        
+    def get_description(self):
-    
+        return _("presents the date")
+
     def run(self):
-        dateFormat = self.env['runtime']['settingsManager'].getSetting('general', 'dateFormat')
+        date_format = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "date_format"
+        )
 
         # get the time formatted
-        dateString = datetime.datetime.strftime(datetime.datetime.now(), dateFormat)
+        date_string = datetime.datetime.strftime(
+            datetime.datetime.now(), date_format
+        )
 
-        # present the time via speak and braile, there is no soundicon, interrupt the current speech
+        # present the time via speak and braile, there is no soundicon,
-        self.env['runtime']['outputManager'].presentText(dateString , soundIcon='', interrupt=True)
+        # interrupt the current speech
+        self.env["runtime"]["OutputManager"].present_text(
+            date_string, sound_icon="", interrupt=True
+        )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/dec_alsa_volume.py

@@ -2,38 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-initialized = False
+import importlib.util
-try:
+import os
-    import alsaaudio
-    initialized = True
-except:
-    pass
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("alsa", "volume", "dec")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass
-    def getDescription(self):
-        return _("Decrease system volume")         
-
-    def run(self):
-        if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('alsaaudio is not installed'), interrupt=True) 
-           return
-        mixer = alsaaudio.Mixer()
-        value = mixer.getvolume()[0]
-        value = value - 5
-        if value < 5:
-            value = 5
-        mixer.setvolume(value)
-        self.env['runtime']['outputManager'].presentText(_("{0} percent system volume").format(value), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/dec_sound_volume.py

@@ -2,32 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("sound", "volume", "dec")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('decrease sound volume')        
-
-    def run(self):
-        
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('sound', 'volume')
-
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.1:
-            value = 0.1  
-        self.env['runtime']['settingsManager'].setSetting('sound', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent sound volume").format(int(value * 100)), soundIcon='SoundOff', interrupt=True)
-   
-    def setCallback(self, callback):
-        pass
-

src/fenrirscreenreader/commands/commands/dec_speech_pitch.py

@@ -2,28 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "pitch", "dec")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the pitch of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'pitch')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.0:
-            value = 0.0 
-        self.env['runtime']['settingsManager'].setSetting('speech', 'pitch', str(value))   
-        self.env['runtime']['outputManager'].presentText(_('{0} percent speech pitch').format(int(value * 100)), soundIcon='', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/dec_speech_rate.py

@@ -2,29 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "rate", "dec")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the rate of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'rate')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.0:
-            value = 0.0 
-        self.env['runtime']['settingsManager'].setSetting('speech', 'rate', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech rate").format(int(value * 100)), soundIcon='', interrupt=True)
-  
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/dec_speech_volume.py

@@ -2,30 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "volume", "dec")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the volume of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'volume')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.1:
-            value = 0.1  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech volume").format(int(value * 100)), soundIcon='', interrupt=True)
-
-    def setCallback(self, callback):
-        pass
-

src/fenrirscreenreader/commands/commands/exit_review.py

@@ -2,27 +2,36 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('exits review mode')        
-    
-    def run(self):
-        if not self.env['runtime']['cursorManager'].isReviewMode():
-            self.env['runtime']['outputManager'].presentText(_("Not in Review Mode"), interrupt=True)
-            return  
 
-        self.env['runtime']['cursorManager'].clearReviewCursor()
+    def shutdown(self):
-        self.env['runtime']['outputManager'].presentText(_("Exiting Review Mode"), interrupt=True)
+        pass
-   
+
-    def setCallback(self, callback):
+    def get_description(self):
+        return _("exits review mode")
+
+    def run(self):
+        if not self.env["runtime"]["CursorManager"].is_review_mode():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Not in Review Mode"), interrupt=True
+            )
+            return
+
+        self.env["runtime"]["CursorManager"].clear_review_cursor()
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Exiting Review Mode"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_file.py

@@ -2,38 +2,66 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import os
 
-class command():
+from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
 
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('export the current fenrir clipboard to a file')
+    def get_description(self):
-    def run(self):  
+        return _("export the current fenrir clipboard to a file")
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
+
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
+    def run(self):
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
+        clipboard_file_path = self.env["runtime"][
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
+            "SettingsManager"
-        clipboardFile = open(clipboardFilePath,'w')        
+        ].get_setting("general", "clipboardExportPath")
+        clipboard_file_path = clipboard_file_path.replace(
+            "$user", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$USER", self.env["general"]["curr_user"]
+        )
+        clipboard_file_path = clipboard_file_path.replace(
+            "$User", self.env["general"]["curr_user"]
+        )
+        clipboard_file = open(clipboard_file_path, "w")
         try:
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+            if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+                "clipboardHistory"
-                return 
+            ):
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')                             
+                self.env["runtime"]["OutputManager"].present_text(
-            clipboardFile.write(clipboard)
+                    _("clipboard empty"), interrupt=True
-            clipboardFile.close()
+                )
-            os.chmod(clipboardFilePath, 0o666)
+                return
-            self.env['runtime']['outputManager'].presentText(_('clipboard exported to file'), interrupt=True)            
+            clipboard = self.env["runtime"][
+                "MemoryManager"
+            ].get_index_list_element("clipboardHistory")
+            clipboard_file.write(clipboard)
+            clipboard_file.close()
+            os.chmod(clipboard_file_path, 0o644)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("clipboard exported to file"), interrupt=True
+            )
         except Exception as e:
-            self.env['runtime']['debug'].writeDebugOut('export_clipboard_to_file:run: Filepath:'+ clipboardFile +' trace:' + str(e),debug.debugLevel.ERROR)                                
+            self.env["runtime"]["DebugManager"].write_debug_out(
-        
+                "export_clipboard_to_file:run: Filepath:"
-    def setCallback(self, callback):
+                + clipboard_file
+                + " trace:"
+                + str(e),
+                debug.DebugLevel.ERROR,
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_x.py

@@ -2,70 +2,96 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
-import os
-import importlib
 import _thread
+import importlib
+import os
+
 import pyperclip
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
-        self.scriptPath = scriptPath
+        self.script_path = script_path
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('Export current fenrir clipboard to X or GUI clipboard')
+    def get_description(self):
-    def run(self):                       
+        return _("Export current fenrir clipboard to X or GUI clipboard")
-       _thread.start_new_thread(self._threadRun , ())
+
-    def _threadRun(self):
+    def run(self):
+        _thread.start_new_thread(self._thread_run, ())
+
+    def _thread_run(self):
         try:
             # Check if clipboard is empty
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+            if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+                "clipboardHistory"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("clipboard empty"), interrupt=True
+                )
                 return
-            
+
             # Get current clipboard content
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            clipboard = self.env["runtime"][
-            
+                "MemoryManager"
+            ].get_index_list_element("clipboardHistory")
+
             # Remember original display environment variable if it exists
-            originalDisplay = os.environ.get('DISPLAY', '')
+            original_display = os.environ.get("DISPLAY", "")
             success = False
-            
+
             # Try different display options
             for i in range(10):
                 display = f":{i}"
                 try:
                     # Set display environment variable
-                    os.environ['DISPLAY'] = display
+                    os.environ["DISPLAY"] = display
                     # Attempt to set clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
+                    # Weird workaround for some distros
+                    importlib.reload(pyperclip)
                     pyperclip.copy(clipboard)
-                    # If we get here without exception, we found a working display
+                    # If we get here without exception, we found a working
+                    # display
                     success = True
                     break
                 except Exception:
                     # Failed for this display, try next one
                     continue
-            
+
             # Restore original display setting
-            if originalDisplay:
+            if original_display:
-                os.environ['DISPLAY'] = originalDisplay
+                os.environ["DISPLAY"] = original_display
             else:
-                os.environ.pop('DISPLAY', None)
+                os.environ.pop("DISPLAY", None)
-            
+
             # Notify the user of the result
             if success:
-                self.env['runtime']['outputManager'].presentText(_('exported to the X session.'), interrupt=True)
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("exported to the X session."), interrupt=True
+                )
             else:
-                self.env['runtime']['outputManager'].presentText(_('failed to export to X clipboard. No available display found.'), interrupt=True)
+                self.env["runtime"]["OutputManager"].present_text(
-                
+                    _(
+                        "failed to export to X clipboard. No available display "
+                        "found."
+                    ),
+                    interrupt=True,
+                )
+
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
+            self.env["runtime"]["OutputManager"].present_text(
-        
+                str(e), sound_icon="", interrupt=False
-    def setCallback(self, callback):
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/first_clipboard.py

@@ -2,27 +2,42 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('selects the first clipboard')        
+    def get_description(self):
-    
+        return _("selects the first clipboard")
-    def run(self):
+
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            return
+            "clipboardHistory"
-        self.env['runtime']['memoryManager'].setFirstIndex('clipboardHistory')     
+        ):
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            self.env["runtime"]["OutputManager"].present_text(
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
+                _("clipboard empty"), interrupt=True
-           
+            )
-    def setCallback(self, callback):
+            return
+        self.env["runtime"]["MemoryManager"].set_first_index(
+            "clipboardHistory"
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/forward_keypress.py

@@ -2,23 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('sends the following keypress to the terminal or application')        
-    
-    def run(self):
-        self.env['input']['keyForeward'] = 3
-        self.env['runtime']['outputManager'].presentText(_('Forward next keypress'), interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("sends the following keypress to the terminal or application")
+
+    def run(self):
+        self.env["input"]["keyForeward"] = 3
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Forward next keypress"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_file.py

@@ -2,38 +2,58 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
 import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import mark_utils
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('imports text from clipboard file to the clipboard')    
+    def get_description(self):
-    
+        return _("imports text from clipboard file to the clipboard")
-    def run(self):
+
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
+    def run(self):
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
+        clipboard_file_path = self.env["runtime"][
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
+            "SettingsManager"
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
+        ].get_setting("general", "clipboardExportPath")
-        if not os.path.exists(clipboardFilePath):
+        clipboard_file_path = clipboard_file_path.replace(
-            self.env['runtime']['outputManager'].presentText(_('File does not exist'), soundIcon='', interrupt=True)        
+            "$user", self.env["general"]["curr_user"]
-            return
+        )
-        clipboardFile = open(clipboardFilePath,'r') 
+        clipboard_file_path = clipboard_file_path.replace(
-        imported = clipboardFile.read()
+            "$USER", self.env["general"]["curr_user"]
-        clipboardFile.close()
+        )
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', imported)        
+        clipboard_file_path = clipboard_file_path.replace(
-
+            "$User", self.env["general"]["curr_user"]
-        self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
+        )
-        self.env['runtime']['outputManager'].presentText(imported, soundIcon='', interrupt=False)        
+        if not os.path.exists(clipboard_file_path):
-        
+            self.env["runtime"]["OutputManager"].present_text(
-
+                _("File does not exist"), sound_icon="", interrupt=True
-    def setCallback(self, callback):
+            )
+            return
+        clipboard_file = open(clipboard_file_path, "r")
+        imported = clipboard_file.read()
+        clipboard_file.close()
+        self.env["runtime"]["MemoryManager"].add_value_to_first_index(
+            "clipboardHistory", imported
+        )
+
+        self.env["runtime"]["OutputManager"].present_text(
+            "Import to Clipboard", sound_icon="CopyToClipboard", interrupt=True
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            imported, sound_icon="", interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_x.py

@@ -2,63 +2,86 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
-import importlib
 import _thread
-import pyperclip
+import importlib
 import os
 
-class command():
+import pyperclip
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-    def initialize(self, environment, scriptPath=''):
+
+    def initialize(self, environment, script_path=""):
         self.env = environment
-        self.scriptPath = scriptPath
+        self.script_path = script_path
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
+    def get_description(self):
         return _("imports the graphical clipboard to Fenrir's clipboard")
-    def run(self):                       
+
-       _thread.start_new_thread(self._threadRun , ())
+    def run(self):
-    def _threadRun(self):
+        _thread.start_new_thread(self._thread_run, ())
+
+    def _thread_run(self):
         try:
             # Remember original display environment variable if it exists
-            originalDisplay = os.environ.get('DISPLAY', '')
+            original_display = os.environ.get("DISPLAY", "")
-            clipboardContent = None
+            clipboard_content = None
-            
+
             # Try different display options
             for i in range(10):
                 display = f":{i}"
                 try:
                     # Set display environment variable
-                    os.environ['DISPLAY'] = display
+                    os.environ["DISPLAY"] = display
                     # Attempt to get clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
+                    # Weird workaround for some distros
-                    clipboardContent = pyperclip.paste()
+                    importlib.reload(pyperclip)
-                    # If we get here without exception, we found a working display
+                    clipboard_content = pyperclip.paste()
-                    if clipboardContent:
+                    # If we get here without exception, we found a working
+                    # display
+                    if clipboard_content:
                         break
                 except Exception:
                     # Failed for this display, try next one
                     continue
-            
+
             # Restore original display setting
-            if originalDisplay:
+            if original_display:
-                os.environ['DISPLAY'] = originalDisplay
+                os.environ["DISPLAY"] = original_display
             else:
-                os.environ.pop('DISPLAY', None)
+                os.environ.pop("DISPLAY", None)
-            
+
             # Process the clipboard content if we found any
-            if clipboardContent and isinstance(clipboardContent, str):
+            if clipboard_content and isinstance(clipboard_content, str):
-                self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', clipboardContent)
+                self.env["runtime"]["MemoryManager"].add_value_to_first_index(
-                self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
+                    "clipboardHistory", clipboard_content
-                self.env['runtime']['outputManager'].presentText(clipboardContent, soundIcon='', interrupt=False)
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    "Import to Clipboard",
+                    sound_icon="CopyToClipboard",
+                    interrupt=True,
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    clipboard_content, sound_icon="", interrupt=False
+                )
             else:
-                self.env['runtime']['outputManager'].presentText('No text found in clipboard or no accessible display', interrupt=True)
+                self.env["runtime"]["OutputManager"].present_text(
+                    "No text found in clipboard or no accessible display",
+                    interrupt=True,
+                )
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
+            self.env["runtime"]["OutputManager"].present_text(
-        
+                str(e), sound_icon="", interrupt=False
-    def setCallback(self, callback):
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/inc_alsa_volume.py

@@ -2,38 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-initialized = False
+import importlib.util
-try:
+import os
-    import alsaaudio
-    initialized = True
-except:
-    pass
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("alsa", "volume", "inc")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass
-    def getDescription(self):
-        return _("Increase system volume")         
-
-    def run(self):
-        if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('alsaaudio is not installed'), interrupt=True) 
-           return
-        mixer = alsaaudio.Mixer()
-        value = mixer.getvolume()[0]
-        value = value + 5
-        if value > 100:
-            value = 100
-        mixer.setvolume(value)
-        self.env['runtime']['outputManager'].presentText(_("{0} percent system volume").format(value), interrupt=True)
-
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/inc_sound_volume.py

@@ -2,31 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("sound", "volume", "inc")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('adjusts the volume for in coming sounds')        
-
-    def run(self):
-        
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('sound', 'volume')
-
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('sound', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent sound volume").format(int(value * 100)),  soundIcon='SoundOn', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/inc_speech_pitch.py

@@ -2,29 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "pitch", "inc")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increases the pitch of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'pitch')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'pitch', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech pitch").format(int(value * 100)), soundIcon='', interrupt=True)
-   
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/inc_speech_rate.py

@@ -2,29 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "rate", "inc")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increase the speech rate')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'rate')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'rate', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech rate").format(int(value * 100)), soundIcon='', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/inc_speech_volume.py

@@ -2,29 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+import importlib.util
-import math
+import os
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+_base_path = os.path.join(os.path.dirname(__file__), "adjustment_base.py")
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+adjustment_command = _module.adjustment_command
+
+
+class command(adjustment_command):
     def __init__(self):
-        pass
+        super().__init__("speech", "volume", "inc")
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increase the speech volume')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'volume')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech volume").format(int(value * 100)), soundIcon='', interrupt=True)
-  
-    def setCallback(self, callback):
-        pass

src/fenrirscreenreader/commands/commands/indent_curr_line.py

@@ -2,35 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Presents the indentation level for the current line')        
+    def get_description(self):
+        return _("Presents the indentation level for the current line")
 
     def run(self):
         # Prefer review cursor over text cursor
 
-        if self.env['screen']['newCursorReview']:
+        if self.env["screen"]["newCursorReview"]:
-            cursorPos = self.env['screen']['newCursorReview'].copy()
+            cursor_pos = self.env["screen"]["newCursorReview"].copy()
         else:
-            cursorPos = self.env['screen']['newCursor'].copy()
+            cursor_pos = self.env["screen"]["new_cursor"].copy()
-        x, y, currLine = \
+        x, y, curr_line = line_utils.get_current_line(
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
+            cursor_pos["x"],
-        
+            cursor_pos["y"],
-        if currLine.isspace():
+            self.env["screen"]["new_content_text"],
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+        )
-        else:        
-            self.env['runtime']['outputManager'].presentText(_("indent {0}").format(len(currLine) - len(currLine.lstrip())), interrupt=True)
 
-    def setCallback(self, callback):
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("indent {0}").format(
+                    len(curr_line) - len(curr_line.lstrip())
+                ),
+                interrupt=True,
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/last_clipboard.py

@@ -2,27 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('selects the last clipboard')        
+    def get_description(self):
-    
+        return _("selects the last clipboard")
-    def run(self):
+
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            return
+            "clipboardHistory"
-        self.env['runtime']['memoryManager'].setLastIndex('clipboardHistory')     
+        ):
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            self.env["runtime"]["OutputManager"].present_text(
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
+                _("clipboard empty"), interrupt=True
-            
+            )
-    def setCallback(self, callback):
+            return
+        self.env["runtime"]["MemoryManager"].set_last_index("clipboardHistory")
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/marked_text.py

@@ -2,37 +2,54 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import mark_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Presents the currently selected text that will be copied to the clipboard')        
+    def get_description(self):
-    
+        return _(
+            "Presents the currently selected text that will be copied to the "
+            "clipboard"
+        )
+
     def run(self):
-        if not (self.env['commandBuffer']['Marks']['1'] and \
+        if not (
-          self.env['commandBuffer']['Marks']['2']):
+            self.env["commandBuffer"]["Marks"]["1"]
-            self.env['runtime']['outputManager'].presentText(_("please set begin and endmark"), interrupt=True)
+            and self.env["commandBuffer"]["Marks"]["2"]
+        ):
+            self.env["runtime"]["OutputManager"].present_text(
+                _("please set begin and endmark"), interrupt=True
+            )
             return
 
         # use the last first and the last setted mark as range
-        startMark = self.env['commandBuffer']['Marks']['1'].copy()
+        start_mark = self.env["commandBuffer"]["Marks"]["1"].copy()
-        endMark = self.env['commandBuffer']['Marks']['2'].copy() 
+        end_mark = self.env["commandBuffer"]["Marks"]["2"].copy()
 
-        marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
+        marked = mark_utils.get_text_between_marks(
+            start_mark, end_mark, self.env["screen"]["new_content_text"]
+        )
 
         if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
-    
+                marked, interrupt=True
-    def setCallback(self, callback):
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_clipboard.py

@@ -2,35 +2,56 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('selects the next clipboard')        
+    def get_description(self):
-    
+        return _("selects the next clipboard")
-    def run(self):
+
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            return      
+            "clipboardHistory"
-        self.env['runtime']['memoryManager'].getNextIndex('clipboardHistory')               
+        ):
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
+            self.env["runtime"]["OutputManager"].present_text(
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
+                _("clipboard empty"), interrupt=True
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
+            )
-        if isFirst:
+            return
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
+        self.env["runtime"]["MemoryManager"].get_next_index("clipboardHistory")
-        if isLast:
+        is_first = self.env["runtime"]["MemoryManager"].is_first_index(
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
+            "clipboardHistory"
-        
+        )
-        speechInterrupt = not(isLast or isFirst)
+        is_last = self.env["runtime"]["MemoryManager"].is_last_index(
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
+            "clipboardHistory"
-             
+        )
-    def setCallback(self, callback):
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        if is_first:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("First clipboard "), interrupt=True
+            )
+        if is_last:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Last clipboard "), interrupt=True
+            )
+
+        speech_interrupt = not (is_last or is_first)
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=speech_interrupt
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_entry.py

@@ -2,28 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get next quick menu entry')
+    def get_description(self):
-    def run(self):
+        return _("get next quick menu entry")
-        menu = ''
+
-        value = ''
+    def run(self):
-        if self.env['runtime']['quickMenuManager'].nextEntry():
+        menu = ""
-            menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
+        value = ""
-            if menu != '':
+        if self.env["runtime"]["QuickMenuManager"].next_entry():
-                value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+            menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+            if menu != "":
-        else:
+                value = self.env["runtime"][
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
+                    "QuickMenuManager"
-    def setCallback(self, callback):
+                ].get_current_value()
+                self.env["runtime"]["OutputManager"].present_text(
+                    menu + " " + value, interrupt=True
+                )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Quick menu not available"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_value.py

@@ -2,22 +2,31 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get next quick menu value')
+    def get_description(self):
-    def run(self):
+        return _("get next quick menu value")
-        if self.env['runtime']['quickMenuManager'].nextValue():
+
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+        if self.env["runtime"]["QuickMenuManager"].next_value():
-    def setCallback(self, callback):
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/paste_clipboard.py

@@ -2,29 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import time
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env["runtime"]["MemoryManager"].add_index_list(
+            "clipboardHistory",
+            self.env["runtime"]["SettingsManager"].get_setting_as_int(
+                "general", "numberOfClipboards"
+            ),
+        )
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('pastes the text from the currently selected clipboard')        
+    def get_description(self):
-    
+        return _("pastes the text from the currently selected clipboard")
-    def run(self):    
+
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            return                                          
+            "clipboardHistory"
-        self.env['runtime']['outputManager'].presentText('paste clipboard', soundIcon='PasteClipboardOnScreen', interrupt=True)
+        ):
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            self.env["runtime"]["OutputManager"].present_text(
-        self.env['runtime']['screenManager'].injectTextToScreen(clipboard)
+                _("clipboard empty"), interrupt=True
-              
+            )
-    def setCallback(self, callback):
+            return
+        self.env["runtime"]["OutputManager"].present_text(
+            "paste clipboard",
+            sound_icon="PasteClipboardOnScreen",
+            interrupt=True,
+        )
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        self.env["runtime"]["ScreenManager"].inject_text_to_screen(clipboard)
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/present_first_line.py

@@ -2,29 +2,38 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('present first line')        
-    
-    def run(self):
-        x, y, firstLine = \
-          line_utils.getCurrentLine(0, 0, self.env['screen']['newContentText'])
-        
-        if firstLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(firstLine, interrupt=True) 
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _("present first line")
+
+    def run(self):
+        x, y, first_line = line_utils.get_current_line(
+            0, 0, self.env["screen"]["new_content_text"]
+        )
+
+        if first_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                first_line, interrupt=True
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/present_last_line.py

@@ -2,29 +2,40 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('current line')        
-    
-    def run(self):
-        x, y, lastLine = \
-          line_utils.getCurrentLine(0, self.env['screen']['lines'] -1, self.env['screen']['newContentText'])
 
-        if lastLine.isspace():
+    def shutdown(self):
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(lastLine, interrupt=True) 
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _("current line")
+
+    def run(self):
+        x, y, last_line = line_utils.get_current_line(
+            0,
+            self.env["screen"]["lines"] - 1,
+            self.env["screen"]["new_content_text"],
+        )
+
+        if last_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                last_line, interrupt=True
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/prev_clipboard.py

@@ -2,34 +2,55 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('selects the previous clipboard')        
+    def get_description(self):
+        return _("selects the previous clipboard")
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
+        if self.env["runtime"]["MemoryManager"].is_index_list_empty(
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+            "clipboardHistory"
-            return      
+        ):
-        self.env['runtime']['memoryManager'].setPrefIndex('clipboardHistory')               
+            self.env["runtime"]["OutputManager"].present_text(
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
+                _("clipboard empty"), interrupt=True
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
+            )
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
+            return
-        if isFirst:
+        self.env["runtime"]["MemoryManager"].set_pref_index("clipboardHistory")
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
+        is_first = self.env["runtime"]["MemoryManager"].is_first_index(
-        if isLast:
+            "clipboardHistory"
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
+        )
-        speechInterrupt = not(isLast or isFirst)
+        is_last = self.env["runtime"]["MemoryManager"].is_last_index(
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
+            "clipboardHistory"
-              
+        )
-    def setCallback(self, callback):
+        clipboard = self.env["runtime"][
+            "MemoryManager"
+        ].get_index_list_element("clipboardHistory")
+        if is_first:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("First clipboard "), interrupt=True
+            )
+        if is_last:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Last clipboard "), interrupt=True
+            )
+        speech_interrupt = not (is_last or is_first)
+        self.env["runtime"]["OutputManager"].present_text(
+            clipboard, interrupt=speech_interrupt
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_entry.py

@@ -2,28 +2,41 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get previous quick menu entry')
+    def get_description(self):
-    def run(self):
+        return _("get previous quick menu entry")
-        menu = ''
+
-        value = ''
+    def run(self):
-        if self.env['runtime']['quickMenuManager'].prevEntry():
+        menu = ""
-            menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
+        value = ""
-            if menu != '':
+        if self.env["runtime"]["QuickMenuManager"].prev_entry():
-                value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+            menu = self.env["runtime"]["QuickMenuManager"].get_current_entry()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+            if menu != "":
-        else:
+                value = self.env["runtime"][
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
+                    "QuickMenuManager"
-    def setCallback(self, callback):
+                ].get_current_value()
+                self.env["runtime"]["OutputManager"].present_text(
+                    menu + " " + value, interrupt=True
+                )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Quick menu not available"), interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_value.py

@@ -2,22 +2,31 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('get previous quick menu value')
+    def get_description(self):
-    def run(self):
+        return _("get previous quick menu value")
-        if self.env['runtime']['quickMenuManager'].prevValue():
+
-            value = self.env['runtime']['quickMenuManager'].getCurrentValue()
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+        if self.env["runtime"]["QuickMenuManager"].prev_value():
-    def setCallback(self, callback):
+            value = self.env["runtime"]["QuickMenuManager"].get_current_value()
+            self.env["runtime"]["OutputManager"].present_text(
+                value, interrupt=True
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/progress_bar_monitor.py

@@ -2,120 +2,254 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 import re
-import time
 import threading
+import time
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
-        
+
     def initialize(self, environment):
         self.env = environment
         # Use commandBuffer like other commands
-        if 'progressMonitoring' not in self.env['commandBuffer']:
+        if "progressMonitoring" not in self.env["commandBuffer"]:
-            # Check if progress monitoring should be enabled by default from settings
+            # Check if progress monitoring should be enabled by default from
+            # settings
             try:
-                defaultEnabled = self.env['runtime']['settingsManager'].getSettingAsBool('sound', 'progressMonitoring')
+                default_enabled = self.env["runtime"][
-            except:
+                    "SettingsManager"
+                ].get_setting_as_bool("sound", "progressMonitoring")
+            except Exception as e:
                 # If setting doesn't exist, default to False
-                defaultEnabled = False
+                default_enabled = False
-            self.env['commandBuffer']['progressMonitoring'] = defaultEnabled
+            self.env["commandBuffer"]["progressMonitoring"] = default_enabled
-            self.env['commandBuffer']['lastProgressTime'] = 0
+            self.env["commandBuffer"]["lastProgressTime"] = 0
-            self.env['commandBuffer']['lastProgressValue'] = -1
+            self.env["commandBuffer"]["lastProgressValue"] = -1
-        
+
     def shutdown(self):
-        self.stopProgressMonitoring()
+        self.stop_progress_monitoring()
-        
+
-    def getDescription(self):
+    def get_description(self):
-        return _('Toggle progress bar monitoring with ascending tones')
+        return _("Toggle progress bar monitoring with ascending tones")
-        
+
     def run(self):
         # Check if commandBuffer exists
-        if 'progressMonitoring' not in self.env['commandBuffer']:
+        if "progressMonitoring" not in self.env["commandBuffer"]:
-            self.env['commandBuffer']['progressMonitoring'] = False
+            self.env["commandBuffer"]["progressMonitoring"] = False
-            self.env['commandBuffer']['lastProgressTime'] = 0
+            self.env["commandBuffer"]["lastProgressTime"] = 0
-            self.env['commandBuffer']['lastProgressValue'] = -1
+            self.env["commandBuffer"]["lastProgressValue"] = -1
-        
+
-        if self.env['commandBuffer']['progressMonitoring']:
+        if self.env["commandBuffer"]["progressMonitoring"]:
-            self.stopProgressMonitoring()
+            self.stop_progress_monitoring()
-            self.env['runtime']['outputManager'].presentText(_("Progress monitoring disabled"), interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
+                _("Progress monitoring disabled"), interrupt=True
+            )
         else:
-            self.startProgressMonitoring()
+            self.start_progress_monitoring()
-            self.env['runtime']['outputManager'].presentText(_("Progress monitoring enabled"), interrupt=True)
+            self.env["runtime"]["OutputManager"].present_text(
-            
+                _("Progress monitoring enabled"), interrupt=True
-    def startProgressMonitoring(self):
+            )
-        self.env['commandBuffer']['progressMonitoring'] = True
+
-        self.env['commandBuffer']['lastProgressTime'] = time.time()
+    def start_progress_monitoring(self):
-        self.env['commandBuffer']['lastProgressValue'] = -1
+        self.env["commandBuffer"]["progressMonitoring"] = True
+        self.env["commandBuffer"]["lastProgressTime"] = time.time()
+        self.env["commandBuffer"]["lastProgressValue"] = -1
         # Don't control speech - let user decide with silence_until_prompt
-        
+
-    def stopProgressMonitoring(self):
+    def stop_progress_monitoring(self):
-        self.env['commandBuffer']['progressMonitoring'] = False
+        self.env["commandBuffer"]["progressMonitoring"] = False
         # Don't control speech - progress monitor is beep-only
-            
+
-    def detectProgress(self, text):
+    def detect_progress(self, text):
-        if not self.env['runtime']['progressMonitoring']:
+        if not self.env["commandBuffer"]["progressMonitoring"]:
             return
-            
+
-        currentTime = time.time()
+        # Skip progress detection if current screen looks like a prompt
-        
+        if self.is_current_line_prompt():
+            return
+
+        current_time = time.time()
+
         # Pattern 1: Percentage (50%, 25.5%, etc.)
-        percentMatch = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
+        percent_match = re.search(r"(\d+(?:\.\d+)?)\s*%", text)
-        if percentMatch:
+        if percent_match:
-            percentage = float(percentMatch.group(1))
+            percentage = float(percent_match.group(1))
-            if percentage != self.env['runtime']['lastProgressValue']:
+            if percentage != self.env["commandBuffer"]["lastProgressValue"]:
-                self.playProgressTone(percentage)
+                self.play_progress_tone(percentage)
-                self.env['runtime']['lastProgressValue'] = percentage
+                self.env["commandBuffer"]["lastProgressValue"] = percentage
-                self.env['runtime']['lastProgressTime'] = currentTime
+                self.env["commandBuffer"]["lastProgressTime"] = current_time
             return
-            
+
         # Pattern 2: Fraction (15/100, 3 of 10, etc.)
-        fractionMatch = re.search(r'(\d+)\s*(?:of|/)\s*(\d+)', text)
+        fraction_match = re.search(r"(\d+)\s*(?:of|/)\s*(\d+)", text)
-        if fractionMatch:
+        if fraction_match:
-            current = int(fractionMatch.group(1))
+            current = int(fraction_match.group(1))
-            total = int(fractionMatch.group(2))
+            total = int(fraction_match.group(2))
             if total > 0:
                 percentage = (current / total) * 100
-                if percentage != self.env['runtime']['lastProgressValue']:
+                if (
-                    self.playProgressTone(percentage)
+                    percentage
-                    self.env['runtime']['lastProgressValue'] = percentage
+                    != self.env["commandBuffer"]["lastProgressValue"]
-                    self.env['runtime']['lastProgressTime'] = currentTime
+                ):
+                    self.play_progress_tone(percentage)
+                    self.env["commandBuffer"]["lastProgressValue"] = percentage
+                    self.env["commandBuffer"][
+                        "lastProgressTime"
+                    ] = current_time
                 return
-                
+
         # Pattern 3: Progress bars ([####    ], [====>   ], etc.)
-        barMatch = re.search(r'\[([#=\-\*]+)([^\]]*)\]', text)
+        # Improved pattern to avoid matching IRC channels like [#channel]
-        if barMatch:
+        bar_match = re.search(r"\[([#=\-\*]+)([\s\.]*)\]", text)
-            filled = len(barMatch.group(1))
+        if bar_match:
-            total = filled + len(barMatch.group(2))
+            filled = len(bar_match.group(1))
-            if total > 0:
+            unfilled = len(bar_match.group(2))
+            total = filled + unfilled
+            # Require at least 2 progress chars total and unfilled portion must
+            # be spaces/dots
+            if total >= 2 and (
+                not bar_match.group(2)
+                or re.match(r"^[\s\.]*$", bar_match.group(2))
+            ):
                 percentage = (filled / total) * 100
-                if percentage != self.env['runtime']['lastProgressValue']:
+                if (
-                    self.playProgressTone(percentage)
+                    percentage
-                    self.env['runtime']['lastProgressValue'] = percentage
+                    != self.env["commandBuffer"]["lastProgressValue"]
-                    self.env['runtime']['lastProgressTime'] = currentTime
+                ):
+                    self.play_progress_tone(percentage)
+                    self.env["commandBuffer"]["lastProgressValue"] = percentage
+                    self.env["commandBuffer"][
+                        "lastProgressTime"
+                    ] = current_time
                 return
-                
+
         # Pattern 4: Generic activity indicators (Loading..., Working..., etc.)
-        activityPattern = re.search(r'(loading|processing|working|installing|downloading|compiling|building).*\.{2,}', text, re.IGNORECASE)
+        activity_pattern = re.search(
-        if activityPattern:
+            (
+                r"(loading|processing|working|installing|downloading|"
+                r"compiling|building).*\.{2,}"
+            ),
+            text,
+            re.IGNORECASE,
+        )
+        if activity_pattern:
             # Play a steady beep every 2 seconds for ongoing activity
-            if currentTime - self.env['runtime']['lastProgressTime'] >= 2.0:
+            if (
-                self.playActivityBeep()
+                current_time - self.env["commandBuffer"]["lastProgressTime"]
-                self.env['runtime']['lastProgressTime'] = currentTime
+                >= 2.0
-                
+            ):
-    def playProgressTone(self, percentage):
+                self.play_activity_beep()
+                self.env["commandBuffer"]["lastProgressTime"] = current_time
+
+    def play_progress_tone(self, percentage):
         # Map 0-100% to 400-1200Hz frequency range
         frequency = 400 + (percentage * 8)
         frequency = max(400, min(1200, frequency))  # Clamp to safe range
-        self.env['runtime']['outputManager'].playFrequence(frequency, 0.15, interrupt=False)
+        self.env["runtime"]["OutputManager"].play_frequence(
-        
+            frequency, 0.15, interrupt=False
-    def playActivityBeep(self):
+        )
+
+    def play_activity_beep(self):
         # Single tone for generic activity
-        self.env['runtime']['outputManager'].playFrequence(800, 0.1, interrupt=False)
+        self.env["runtime"]["OutputManager"].play_frequence(
-        
+            800, 0.1, interrupt=False
-    def setCallback(self, callback):
+        )
-        pass
+
+    def is_current_line_prompt(self):
+        """Check if the current line looks like a standalone prompt (not command with progress)"""
+        import re
+
+        try:
+            # Get the current screen content
+            if not self.env["screen"]["new_content_text"]:
+                return False
+
+            lines = self.env["screen"]["new_content_text"].split("\n")
+            if not lines:
+                return False
+
+            # Check the last line (most common) and current cursor line for
+            # prompt patterns
+            lines_to_check = []
+
+            # Add last line (most common for prompts)
+            if lines:
+                lines_to_check.append(lines[-1])
+
+            # Add current cursor line if different from last line
+            if (
+                self.env["screen"]["new_cursor"]["y"] < len(lines)
+                and self.env["screen"]["new_cursor"]["y"] != len(lines) - 1
+            ):
+                lines_to_check.append(
+                    lines[self.env["screen"]["new_cursor"]["y"]]
+                )
+
+            # Standalone prompt patterns (no commands mixed in)
+            standalone_prompt_patterns = [
+                r"^\s*\$\s*$",  # Just $ (with whitespace)
+                r"^\s*#\s*$",  # Just # (with whitespace)
+                r"^\s*>\s*$",  # Just > (with whitespace)
+                r"^\[.*\]\s*[\\\$#>]\s*$",  # [path]$ without commands
+                r"^[a-zA-Z0-9._-]+[\\\$#>]\s*$",  # bash-5.1$ without commands
+                # Interactive prompt patterns (these ARE standalone)
+                r".*\?\s*\[[YyNn]/[YyNn]\]\s*$",  # ? [Y/n] or ? [y/N] style
+                r".*\?\s*\[[Yy]es/[Nn]o\]\s*$",  # ? [Yes/No] style
+                # "continue? [Y/n]" style
+                r".*continue\?\s*\[[YyNn]/[YyNn]\].*$",
+                r"^::.*\?\s*\[[YyNn]/[YyNn]\].*$",  # pacman style prompts
+                # Authentication prompts (these ARE standalone)
+                r"^\[[Ss]udo\]\s*[Pp]assword\s*for\s+.*:\s*$",  # [sudo] password
+                r"^[Pp]assword\s*:\s*$",  # Password:
+                r".*[Pp]assword\s*:\s*$",  # general password prompts
+                # Continuation prompts (these ARE standalone)
+                r"^[Pp]ress\s+any\s+key\s+to\s+continue.*$",  # Press any key
+                r"^[Aa]re\s+you\s+sure\?\s*.*$",  # Are you sure?
+            ]
+
+            for line in lines_to_check:
+                line = line.strip()
+                if not line:
+                    continue
+
+                # Check if this line contains both a prompt AND other content (like commands)
+                # If so, don't treat it as a standalone prompt
+                has_prompt_marker = bool(
+                    re.search(r".*@.*[\\\$#>]", line)
+                    or re.search(r"^\[.*\]\s*[\\\$#>]", line)
+                )
+                if has_prompt_marker:
+                    # If line has prompt marker but also has significant content after it,
+                    # it's a command line, not a standalone prompt
+                    prompt_end = max(
+                        line.rfind("$"),
+                        line.rfind("#"),
+                        line.rfind(">"),
+                        line.rfind("\\"),
+                    )
+                    if (
+                        prompt_end >= 0 and prompt_end < len(line) - 5
+                    ):  # More than just whitespace after prompt
+                        continue  # This is a command line, not a standalone prompt
+
+                for pattern in standalone_prompt_patterns:
+                    try:
+                        if re.search(pattern, line):
+                            return True
+                    except re.error:
+                        continue
+
+            return False
+
+        except Exception as e:
+            # If anything fails, assume it's not a prompt to be safe
+            return False
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/quit_fenrir.py

@@ -2,23 +2,27 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('exits Fenrir')        
-    
-    def run(self):
-        self.env['runtime']['eventManager'].stopMainEventLoop() 
 
-    def setCallback(self, callback):
+    def shutdown(self):
         pass
 
+    def get_description(self):
+        return _("exits Fenrir")
+
+    def run(self):
+        self.env["runtime"]["EventManager"].stop_main_event_loop()
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/remove_marks.py

@@ -2,23 +2,30 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Removes marks from selected text')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].clearMarks()
-        self.env['runtime']['outputManager'].presentText(_('Remove marks'), interrupt=True)
 
-    def setCallback(self, callback):
+    def shutdown(self):
+        pass
+
+    def get_description(self):
+        return _("Removes marks from selected text")
+
+    def run(self):
+        self.env["runtime"]["CursorManager"].clear_marks()
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Remove marks"), interrupt=True
+        )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/remove_word_from_spell_check.py

@@ -2,54 +2,96 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import word_utils
 import string
+
+from fenrirscreenreader.core.i18n import _
+from fenrirscreenreader.utils import word_utils
+
 initialized = False
 try:
     import enchant
+
     initialized = True
-except:
+except Exception as e:
     pass
-    
+
-class command():
+
+class command:
     def __init__(self):
-        self.language = ''
+        self.language = ""
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
-        self.updateSpellLanguage()
+        self.update_spell_language()
+
     def shutdown(self):
         pass
-    def getDescription(self):
+
-        return _('removes the current word from the exceptions dictionary')        
+    def get_description(self):
-    def updateSpellLanguage(self):  
+        return _("removes the current word from the exceptions dictionary")
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
+
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
+    def update_spell_language(self):
-       
+        self.spellChecker = enchant.Dict(
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+        )
+        self.language = self.env["runtime"]["SettingsManager"].get_setting(
+            "general", "spellCheckLanguage"
+        )
+
     def run(self):
         if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('pyenchant is not installed'), interrupt=True) 
+            self.env["runtime"]["OutputManager"].present_text(
-           return
+                _("pyenchant is not installed"), interrupt=True
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+            )
+            return
+        if (
+            self.env["runtime"]["SettingsManager"].get_setting(
+                "general", "spellCheckLanguage"
+            )
+            != self.language
+        ):
             try:
-                self.updateSpellLanguage()
+                self.update_spell_language()
-            except:
+            except Exception as e:
-                return    
+                return
+
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
 
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-            
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
+        new_content = self.env["screen"]["new_content_text"].split("\n")[
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)                  
+            cursor_pos["y"]
-        currWord = currWord.strip(string.whitespace + r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
+        ]
-        if not currWord.isspace():
+        x, y, curr_word, end_of_screen, line_break = (
-            if self.spellChecker.is_removed(currWord):
+            word_utils.get_current_word(cursor_pos["x"], 0, new_content)
-                self.env['runtime']['outputManager'].presentText(_('{0} is not in the dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+        )
+        curr_word = curr_word.strip(
+            string.whitespace + r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~'
+        )
+        if not curr_word.isspace():
+            if self.spellChecker.is_removed(curr_word):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("{0} is not in the dictionary").format(
+                        curr_word,
+                    ),
+                    sound_icon="Cancel",
+                    interrupt=True,
+                )
             else:
-                self.spellChecker.remove(currWord)             
+                self.spellChecker.remove(curr_word)
-                self.env['runtime']['outputManager'].presentText(_('{0} removed').format(currWord,), soundIcon='Accept', interrupt=True)                    
+                self.env["runtime"]["OutputManager"].present_text(
-    def setCallback(self, callback):
+                    _("{0} removed").format(
+                        curr_word,
+                    ),
+                    sound_icon="Accept",
+                    interrupt=True,
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_bottom.py

@@ -2,23 +2,33 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
 
-class command():
+from fenrirscreenreader.core.i18n import _
+
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Move review to the bottom of the screen')
+    def get_description(self):
+        return _("Move review to the bottom of the screen")
 
     def run(self):
-        self.env['screen']['newCursorReview'] = { 'x': 0, 'y':self.env['screen']['lines'] -1}
+        self.env["screen"]["newCursorReview"] = {
-        self.env['runtime']['outputManager'].presentText(_("Bottom"), interrupt=True, flush=False)
+            "x": 0,
+            "y": self.env["screen"]["lines"] - 1,
+        }
+        self.env["runtime"]["OutputManager"].present_text(
+            _("Bottom"), interrupt=True, flush=False
+        )
 
-    def setCallback(self, callback):
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char.py

@@ -2,35 +2,82 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('presents the current character.')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
+    def shutdown(self):
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        pass
-        
+
-        self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
+    def get_description(self):
-        # is has attribute it enabled?    
+        return _("presents the current character.")
-        if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
+
-            cursorPos = self.env['screen']['newCursorReview']
+    def run(self):
-            
+        self.env["runtime"][
-            if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
+            "CursorManager"
-                return
+        ].enter_review_mode_curr_text_cursor()
-            self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)        
+
-  
+        # In table mode, sync to cell start if cursor is outside current cell
-    def setCallback(self, callback):
+        if self.env["runtime"]["TableManager"].is_table_mode():
+            table_info = self.env["runtime"]["TableManager"].get_current_table_cell_info()
+            if table_info:
+                cursor_pos = self.env["screen"]["newCursorReview"]
+                line_text = self.env["runtime"]["ScreenManager"].get_line_text(
+                    cursor_pos["y"]
+                )
+                if line_text:
+                    column_start = self.env["runtime"]["TableManager"].get_column_start_position(
+                        line_text, table_info["column_index"]
+                    )
+                    cell_content = table_info["cell_content"]
+                    cell_end = column_start + len(cell_content)
+                    
+                    # If cursor is outside the current cell, move to cell start
+                    if (
+                        cursor_pos["x"] < column_start or 
+                        cursor_pos["x"] >= cell_end
+                    ):
+                        self.env["screen"]["newCursorReview"]["x"] = column_start
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        char_utils.present_char_for_review(
+            self.env,
+            curr_char,
+            interrupt=True,
+            announce_capital=True,
+            flush=False,
+        )
+        # is has attribute it enabled?
+        if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+            "general", "hasattributes"
+        ):
+            cursor_pos = self.env["screen"]["newCursorReview"]
+
+            if not self.env["runtime"]["AttributeManager"].has_attributes(
+                cursor_pos
+            ):
+                return
+            self.env["runtime"]["OutputManager"].present_text(
+                "has attribute", sound_icon="HasAttributes", interrupt=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char_phonetic.py

@@ -2,32 +2,49 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('set review and phonetically presents the current character')    
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
+    def shutdown(self):
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        pass
-        
+
-        if currChar.isspace():
+    def get_description(self):
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+        return _("set review and phonetically presents the current character")
-        else:
+
-            currChar = char_utils.getPhonetic(currChar)
+    def run(self):
-            self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, announceCapital=True, flush=False)
+        self.env["runtime"][
-  
+            "CursorManager"
-    def setCallback(self, callback):
+        ].enter_review_mode_curr_text_cursor()
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_char.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), interrupt=True, flush=False
+            )
+        else:
+            curr_char = char_utils.get_phonetic(curr_char)
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_char, interrupt=True, announce_capital=True, flush=False
+            )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_line.py

@@ -2,31 +2,48 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import line_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('current line')        
-    
-    def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currLine = \
+    def shutdown(self):
-          line_utils.getCurrentLine(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
-        
-        if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
-        else:
-            self.env['runtime']['outputManager'].presentText(currLine, interrupt=True, flush=False) 
-    def setCallback(self, callback):
         pass
 
+    def get_description(self):
+        return _("current line")
+
+    def run(self):
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
+
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_line,
+        ) = line_utils.get_current_line(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_line.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), sound_icon="EmptyLine", interrupt=True, flush=False
+            )
+        else:
+            self.env["runtime"]["OutputManager"].present_text(
+                curr_line, interrupt=True, flush=False
+            )
+
+    def set_callback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/review_curr_word.py

@@ -2,36 +2,99 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import word_utils
+from fenrirscreenreader.core import debug
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-            return _('current word.')        
+    def get_description(self):
+        return _("current word.")
 
     def run(self):
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
+        self.env["runtime"][
+            "CursorManager"
+        ].enter_review_mode_curr_text_cursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
+        (
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+            self.env["screen"]["newCursorReview"]["x"],
-        
+            self.env["screen"]["newCursorReview"]["y"],
-        if currWord.isspace():
+            curr_word,
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+            end_of_screen,
+            line_break,
+        ) = word_utils.get_current_word(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        # Check if we're in table mode and provide table-aware output
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
+        self.env["runtime"]["DebugManager"].write_debug_out(
+            f"review_curr_word: is_table_mode={is_table_mode}",
+            debug.DebugLevel.INFO
+        )
+        if is_table_mode:
+            # Get current cell info using internal column tracking
+            table_info = (
+                self.env["runtime"]["TableManager"].get_current_table_cell_info()
+            )
+            if table_info:
+                # Announce with table context - cell content first, then header
+                output_text = (
+                    f"{table_info['cell_content']} {table_info['column_header']}"
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    output_text, interrupt=True, flush=False
+                )
+                return  # Exit early for table mode
+            else:
+                # Fallback to regular word announcement
+                if curr_word.isspace():
+                    self.env["runtime"]["OutputManager"].present_text(
+                        _("blank"), interrupt=True, flush=False
+                    )
+                else:
+                    self.env["runtime"]["OutputManager"].present_text(
+                        curr_word, interrupt=True, flush=False
+                    )
         else:
-            self.env['runtime']['outputManager'].presentText(currWord, interrupt=True, flush=False)
+            # Regular word announcement
-        if endOfScreen:
+            if curr_word.isspace():
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
+                self.env["runtime"]["OutputManager"].present_text(
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')
+                    _("blank"), interrupt=True, flush=False
-        if lineBreak:
+                )
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
+            else:
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
+                self.env["runtime"]["OutputManager"].present_text(
-    def setCallback(self, callback):
+                    curr_word, interrupt=True, flush=False
+                )
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+        if line_break:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "line_break"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("line break"), interrupt=False, sound_icon="EndOfLine"
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_word_phonetic.py

@@ -2,40 +2,73 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
-from fenrirscreenreader.utils import word_utils
 from fenrirscreenreader.utils import char_utils
+from fenrirscreenreader.utils import word_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Phonetically spells the current word')        
+    def get_description(self):
-    
+        return _("Phonetically spells the current word")
-    def run(self):
+
-        self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
+    def run(self):
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
+        self.env["runtime"][
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+            "CursorManager"
-        
+        ].enter_review_mode_curr_text_cursor()
-        if currWord.isspace():
+        (
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+            self.env["screen"]["newCursorReview"]["x"],
-        else:
+            self.env["screen"]["newCursorReview"]["y"],
-            firstSequence = True
+            curr_word,
-            for c in currWord:
+            end_of_screen,
-                currChar = char_utils.getPhonetic(c) 
+            line_break,
-                self.env['runtime']['outputManager'].presentText(currChar, interrupt=firstSequence, announceCapital=True, flush=False)
+        ) = word_utils.get_current_word(
-                firstSequence = False
+            self.env["screen"]["newCursorReview"]["x"],
-        if endOfScreen:
+            self.env["screen"]["newCursorReview"]["y"],
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
+            self.env["screen"]["new_content_text"],
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                 
+        )
-        if lineBreak:
+
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
+        if curr_word.isspace():
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')   
+            self.env["runtime"]["OutputManager"].present_text(
-    def setCallback(self, callback):
+                _("blank"), interrupt=True, flush=False
+            )
+        else:
+            first_sequence = True
+            for c in curr_word:
+                curr_char = char_utils.get_phonetic(c)
+                self.env["runtime"]["OutputManager"].present_text(
+                    curr_char,
+                    interrupt=first_sequence,
+                    announce_capital=True,
+                    flush=False,
+                )
+                first_sequence = False
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+        if line_break:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "line_break"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("line break"), interrupt=False, sound_icon="EndOfLine"
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_down.py

@@ -2,28 +2,55 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('Move review to the character below the current position')        
+    def get_description(self):
+        return _("Move review to the character below the current position")
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        cursor_pos = self.env["runtime"][
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], downChar, endOfScreen = \
+            "CursorManager"
-          char_utils.getDownChar(self.env['screen']['newCursorReview']['x'],self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        ].get_review_or_text_cursor()
-        self.env['runtime']['outputManager'].presentText(downChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
+        (
-        if endOfScreen:
+            self.env["screen"]["newCursorReview"]["x"],
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
+            self.env["screen"]["newCursorReview"]["y"],
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                     
+            downChar,
-    def setCallback(self, callback):
+            end_of_screen,
+        ) = char_utils.get_down_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+        self.env["runtime"]["OutputManager"].present_text(
+            downChar,
+            interrupt=True,
+            ignore_punctuation=True,
+            announce_capital=True,
+            flush=False,
+        )
+        if end_of_screen:
+            if self.env["runtime"]["SettingsManager"].get_setting_as_bool(
+                "review", "end_of_screen"
+            ):
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("end of screen"),
+                    interrupt=True,
+                    sound_icon="EndOfScreen",
+                )
+
+    def set_callback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_line_begin.py

@@ -2,32 +2,80 @@
 # -*- coding: utf-8 -*-
 
 # Fenrir TTY screen reader
-# By Chrys, Storm Dragon, and contributers.
+# By Chrys, Storm Dragon, and contributors.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 from fenrirscreenreader.utils import char_utils
 
-class command():
+
+class command:
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
-        pass 
+        pass
-    def getDescription(self):
+
-        return _('set review cursor to begin of current line and display the content')
+    def get_description(self):
+        return _(
+            "set review cursor to begin of current line and display the content"
+        )
 
     def run(self):
-        cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
+        # Check if we're in table mode first
-        self.env['runtime']['cursorManager'].setReviewCursorPosition(0 ,cursorPos['y'])
+        is_table_mode = self.env["runtime"]["TableManager"].is_table_mode()
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
+        if is_table_mode:
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+            table_info = self.env["runtime"]["TableManager"].move_to_first_cell()
+            if table_info:
+                output_text = (
+                    f"{table_info['cell_content']} {table_info['column_header']}"
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    output_text, interrupt=True, flush=False
+                )
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("first cell"), interrupt=False
+                )
+            else:
+                self.env["runtime"]["OutputManager"].present_text(
+                    _("no table data"), interrupt=True, flush=False
+                )
+            return
         
-        if currChar.isspace():
+        # Regular line begin navigation (when not in table mode)
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+        cursor_pos = self.env["runtime"][
+            "CursorManager"
+        ].get_review_or_text_cursor()
+        self.env["runtime"]["CursorManager"].set_review_cursor_position(
+            0, cursor_pos["y"]
+        )
+        (
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            curr_char,
+        ) = char_utils.get_current_char(
+            self.env["screen"]["newCursorReview"]["x"],
+            self.env["screen"]["newCursorReview"]["y"],
+            self.env["screen"]["new_content_text"],
+        )
+
+        if curr_char.isspace():
+            self.env["runtime"]["OutputManager"].present_text(
+                _("blank"), interrupt=True, flush=False
+            )
         else:
-            self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
+            self.env["runtime"]["OutputManager"].present_text(
-        self.env['runtime']['outputManager'].presentText(_("beginning of line"), interrupt=False)
+                curr_char,
-   
+                interrupt=True,
-    def setCallback(self, callback):
+                ignore_punctuation=True,
+                announce_capital=True,
+                flush=False,
+            )
+        self.env["runtime"]["OutputManager"].present_text(
+            _("beginning of line"), interrupt=False
+        )
+
+    def set_callback(self, callback):
         pass