Merge pull request #13 from agessaman/dev-localization

Localization and some international functionality improvements.

Author: agessaman

config.ini.example

@@ -85,6 +85,21 @@ bot_latitude = 40.7128
 # Example: -74.0060 for New York City, -123.00 for Victoria BC
 bot_longitude = -74.0060
 
+[Localization]
+# Language code for bot responses (en, es, es-MX, es-ES, fr, de, ja, etc.)
+# Default: en (English)
+# The bot will use translations from translations/{language}.json
+# Supports locale codes:
+#   - Simple codes: en, es, fr, de, ja
+#   - Locale codes: es-MX (Mexican Spanish), es-ES (Spain Spanish), fr-CA (Canadian French)
+# If locale-specific file not found, falls back to base language (e.g., es.json)
+# If translation file is missing or key not found, falls back to English
+language = en
+
+# Path to translation files directory (relative to bot root)
+# Default: translations/
+translation_path = translations/
+
 [Admin_ACL]
 # Admin Access Control List (ACL) for restricted commands
 # Only users with public keys listed here can execute admin commands
@@ -171,14 +186,16 @@ advert_interval_hours = 0
 
 [Keywords]
 # Keyword-response pairs (keyword = response format)
-# Available fields: {sender}, {connection_info}, {snr}, {timestamp}, {path}
+# Available fields: {sender}, {connection_info}, {snr}, {timestamp}, {path}, {path_distance}, {firstlast_distance}
 # {sender}: Name/ID of message sender
 # {connection_info}: "Direct connection (0 hops)" or "Routed through X hops"
 # {snr}: Signal-to-noise ratio in dB
 # {timestamp}: Message timestamp in HH:MM:SS format
 # {path}: Message routing path (e.g., "01,5f (2 hops)")
 # {rssi}: Received Signal Strength Indicator in dBm
-test = "ack {sender}{phrase_part} | {connection_info} | Received at: {timestamp}"
+# {path_distance}: Total distance between all hops in path with locations (e.g., "123.4km (3 segs, 1 no-loc)")
+# {firstlast_distance}: Distance between first and last repeater in path (e.g., "45.6km" or empty if locations missing)
+test = "ack @[{sender}]{phrase_part} | {connection_info} | Received at: {timestamp}"
 ping = "Pong!"
 pong = "Ping!"
 help = "Bot Help: test (or t), ping, help, hello, cmd, advert, @string, wx, aqi, sun, moon, solar, hfcond, satpass, prefix, path, sports, dice, roll, stats | Use 'help <command>' for details"
@@ -235,8 +252,10 @@ meshcore_log_level = INFO
 [Custom_Syntax]
 # Custom syntax patterns for special message formats
 # Format: pattern = "response_format"
-# Available fields: {sender}, {phrase}, {connection_info}, {snr}, {timestamp}, {path}
+# Available fields: {sender}, {phrase}, {connection_info}, {snr}, {timestamp}, {path}, {path_distance}, {firstlast_distance}
 # {phrase}: The text after the trigger (for custom syntax patterns)
+# {path_distance}: Total distance between all hops in path with locations (e.g., "123.4km (3 segs, 1 no-loc)")
+# {firstlast_distance}: Distance between first and last repeater in path (e.g., "45.6km" or empty if locations missing)
 # 
 # Note: The "t" command is now handled by the test command as an alias
 # "t phrase" works the same as "test phrase" - both use the test response format

modules/command_manager.py

@@ -145,19 +145,28 @@ def check_keywords(self, message: MeshMessage) -> List[tuple]:
         content_lower = content.lower()
 
         # Check for help requests first (special handling)
-        if content_lower.startswith('help '):
-            command_name = content_lower[5:].strip()  # Remove "help " prefix
-            help_text = self.get_help_for_command(command_name, message)
-            # Format the help response with message data (same as other keywords)
-            help_text = self.format_keyword_response(help_text, message)
-            matches.append(('help', help_text))
-            return matches
-        elif content_lower == 'help':
-            help_text = self.get_general_help()
-            # Format the help response with message data (same as other keywords)
-            help_text = self.format_keyword_response(help_text, message)
-            matches.append(('help', help_text))
-            return matches
+        # Check both English "help" and translated help keywords
+        help_keywords = ['help']
+        if 'help' in self.commands:
+            help_command = self.commands['help']
+            if hasattr(help_command, 'keywords'):
+                help_keywords = [k.lower() for k in help_command.keywords]
+        
+        # Check if message starts with any help keyword
+        for help_keyword in help_keywords:
+            if content_lower.startswith(help_keyword + ' '):
+                command_name = content_lower[len(help_keyword):].strip()  # Remove help keyword prefix
+                help_text = self.get_help_for_command(command_name, message)
+                # Format the help response with message data (same as other keywords)
+                help_text = self.format_keyword_response(help_text, message)
+                matches.append(('help', help_text))
+                return matches
+            elif content_lower == help_keyword:
+                help_text = self.get_general_help()
+                # Format the help response with message data (same as other keywords)
+                help_text = self.format_keyword_response(help_text, message)
+                matches.append(('help', help_text))
+                return matches
 
         # Check all loaded plugins for matches
         for command_name, command in self.commands.items():
@@ -360,6 +369,9 @@ def get_help_for_command(self, command_name: str, message: MeshMessage = None) -
             except TypeError:
                 # Fallback for commands that don't accept message parameter
                 help_text = command.get_help_text()
+            # Use translator if available
+            if hasattr(self.bot, 'translator'):
+                return self.bot.translator.translate('commands.help.specific', command=command_name, help_text=help_text)
             return f"Help {command_name}: {help_text}"
 
         # If not found, search through all commands and their keywords
@@ -372,6 +384,9 @@ def get_help_for_command(self, command_name: str, message: MeshMessage = None) -
                 except TypeError:
                     # Fallback for commands that don't accept message parameter
                     help_text = cmd_instance.get_help_text()
+                # Use translator if available
+                if hasattr(self.bot, 'translator'):
+                    return self.bot.translator.translate('commands.help.specific', command=command_name, help_text=help_text)
                 return f"Help {command_name}: {help_text}"
 
         # If still not found, return unknown command message with helpful suggestion
@@ -381,7 +396,10 @@ def get_help_for_command(self, command_name: str, message: MeshMessage = None) -
             if hasattr(cmd_instance, 'keywords'):
                 available_commands.extend(cmd_instance.keywords)
 
-        return f"Unknown: {command_name}. Available: {', '.join(sorted(set(available_commands)))}. Try 'help' for command list."
+        available_str = ', '.join(sorted(set(available_commands)))
+        if hasattr(self.bot, 'translator'):
+            return self.bot.translator.translate('commands.help.unknown', command=command_name, available=available_str)
+        return f"Unknown: {command_name}. Available: {available_str}. Try 'help' for command list."
 
     def get_general_help(self) -> str:
         """Get general help text from config (LoRa-friendly compact format)"""
@@ -481,9 +499,11 @@ async def execute_commands(self, message):
                 # Check if command can execute (cooldown, DM requirements, etc.)
                 if not command.can_execute_now(message):
                     if command.requires_dm and not message.is_dm:
-                        await self.send_response(message, f"Command '{command_name}' can only be used in DMs")
+                        error_msg = command.translate('errors.dm_only', command=command_name)
+                        await self.send_response(message, error_msg)
                     elif command.requires_admin_access():
-                        await self.send_response(message, f"❌ Access denied: Command '{command_name}' requires admin privileges")
+                        error_msg = command.translate('errors.access_denied', command=command_name)
+                        await self.send_response(message, error_msg)
                     elif hasattr(command, 'get_remaining_cooldown') and callable(command.get_remaining_cooldown):
                         # Check if it's the per-user version (takes user_id parameter)
                         import inspect
@@ -494,7 +514,8 @@ async def execute_commands(self, message):
                             remaining = command.get_remaining_cooldown()
 
                         if remaining > 0:
-                            await self.send_response(message, f"Command '{command_name}' is on cooldown. Wait {remaining} seconds.")
+                            error_msg = command.translate('errors.cooldown', command=command_name, seconds=remaining)
+                            await self.send_response(message, error_msg)
                     return
 
                 try:
@@ -536,7 +557,8 @@ async def execute_commands(self, message):
                 except Exception as e:
                     self.logger.error(f"Error executing command '{command_name}': {e}")
                     # Send error message to user
-                    await self.send_response(message, f"Error executing {command_name}: {e}")
+                    error_msg = command.translate('errors.execution_error', command=command_name, error=str(e))
+                    await self.send_response(message, error_msg)
 
                     # Capture failed command for web viewer
                     if (hasattr(self.bot, 'web_viewer_integration') and 

modules/commands/advert_command.py

@@ -21,7 +21,7 @@ class AdvertCommand(BaseCommand):
     category = "special"
 
     def get_help_text(self) -> str:
-        return self.description
+        return self.translate('commands.advert.description')
 
     def can_execute(self, message: MeshMessage) -> bool:
         """Check if advert command can be executed"""
@@ -45,7 +45,7 @@ async def execute(self, message: MeshMessage) -> bool:
             if hasattr(self.bot, 'last_advert_time') and self.bot.last_advert_time and (current_time - self.bot.last_advert_time) < 3600:
                 remaining_time = 3600 - (current_time - self.bot.last_advert_time)
                 remaining_minutes = int(remaining_time // 60)
-                response = f"Advert cooldown active. Please wait {remaining_minutes} more minutes before requesting another advert."
+                response = self.translate('commands.advert.cooldown_active', minutes=remaining_minutes)
                 await self.send_response(message, response)
                 return True
 
@@ -58,14 +58,14 @@ async def execute(self, message: MeshMessage) -> bool:
             if hasattr(self.bot, 'last_advert_time'):
                 self.bot.last_advert_time = current_time
 
-            response = "Flood advert sent successfully!"
+            response = self.translate('commands.advert.success')
             self.logger.info("Flood advert sent successfully via DM command")
 
             await self.send_response(message, response)
             return True
 
         except Exception as e:
-            error_msg = f"Error sending flood advert: {e}"
-            self.logger.error(error_msg)
+            error_msg = self.translate('commands.advert.error', error=str(e))
+            self.logger.error(f"Error sending flood advert: {e}")
             await self.send_response(message, error_msg)
             return False