feat(i18n): Add comprehensive multi-language support for 12 languages

.github/codeql-config.yml

@@ -0,0 +1,6 @@
+# CodeQL Configuration for Cortex Linux
+# Uses default setup (no advanced configuration)
+name: "CodeQL"
+queries:
+  - uses: security-extended
+  - uses: security-and-quality

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,45 @@
+name: CodeQL Analysis
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  schedule:
+    - cron: '0 0 * * 0'
+
+permissions:
+  security-events: write
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        config-file: .github/codeql-config.yml
+
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{ matrix.language }}"

AGENTS.md

@@ -75,6 +75,10 @@ cortex-detect-hardware
 - All tests must pass
 - Documentation required for new features
 
+## AI/IDE Agents Used
+
+Used Cursor Copilot with Claude Opus 4.5 model for generating test cases and documentation. Core implementation was done manually.
+
 ## Contact
 
 - Discord: https://discord.gg/uCqHvxjU83

cortex/cli.py

@@ -10,6 +10,7 @@
 from cortex.api_key_detector import auto_detect_api_key, setup_api_key
 from cortex.ask import AskHandler
 from cortex.branding import VERSION, console, cx_header, cx_print, show_banner
+from cortex.config_manager import ConfigManager
 from cortex.coordinator import InstallationCoordinator, InstallationStep, StepStatus
 from cortex.demo import run_demo
 from cortex.dependency_importer import (
@@ -19,6 +20,7 @@
     format_package_list,
 )
 from cortex.env_manager import EnvironmentManager, get_env_manager
+from cortex.i18n import LanguageManager
 from cortex.installation_history import InstallationHistory, InstallationStatus, InstallationType
 from cortex.llm.interpreter import CommandInterpreter
 from cortex.network_config import NetworkConfig
@@ -37,11 +39,34 @@
 
 
 class CortexCLI:
-    def __init__(self, verbose: bool = False):
+    def __init__(self, verbose: bool = False, language: str | None = None):
         self.spinner_chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
         self.spinner_idx = 0
         self.verbose = verbose
 
+        # Initialize language manager with ConfigManager for saved preferences
+        config_mgr = ConfigManager()
+        self.lang_manager = LanguageManager(prefs_manager=config_mgr)
+        detected_language = language or self.lang_manager.detect_language()
+        from cortex.i18n import get_translator
+
+        self.translator = get_translator(detected_language)
+
+    def t(self, key: str, **kwargs) -> str:
+        """Get a translated string by key.
+
+        Shortcut method that delegates to self.translator.get() for retrieving
+        localized strings with optional variable interpolation.
+
+        Args:
+            key: Translation key in dot notation (e.g., 'install.success').
+            **kwargs: Variables for string interpolation (e.g., package='nginx').
+
+        Returns:
+            str: The translated string, or a fallback placeholder if key is missing.
+        """
+        return self.translator.get(key, **kwargs)
+
     # Define a method to handle Docker-specific permission repairs
     def docker_permissions(self, args: argparse.Namespace) -> int:
         """Handle the diagnosis and repair of Docker file permissions.
@@ -514,11 +539,19 @@ def _sandbox_test(self, sandbox, args: argparse.Namespace) -> int:
 
     def _sandbox_promote(self, sandbox, args: argparse.Namespace) -> int:
         """Promote a tested package to main system."""
+        from cortex.validators import validate_package_name
+
         name = args.name
         package = args.package
         dry_run = getattr(args, "dry_run", False)
         skip_confirm = getattr(args, "yes", False)
 
+        # Validate package name before passing to system commands
+        is_valid, error = validate_package_name(package)
+        if not is_valid:
+            self._print_error(f"Invalid package name: {error}")
+            return 1
+
         if dry_run:
             result = sandbox.promote(name, package, dry_run=True)
             cx_print(f"Would run: sudo apt-get install -y {package}", "info")
@@ -672,22 +705,20 @@ def install(
         start_time = datetime.now()
 
         try:
-            self._print_status("🧠", "Understanding request...")
+            self._print_status("🧠", self.t("status.understanding"))
 
             interpreter = CommandInterpreter(api_key=api_key, provider=provider)
 
-            self._print_status("📦", "Planning installation...")
+            self._print_status("📦", self.t("status.planning"))
 
             for _ in range(10):
-                self._animate_spinner("Analyzing system requirements...")
+                self._animate_spinner(self.t("status.analyzing"))
             self._clear_line()
 
             commands = interpreter.parse(f"install {software}")
 
             if not commands:
-                self._print_error(
-                    "No commands generated. Please try again with a different request."
-                )
+                self._print_error(self.t("errors.no_commands"))
                 return 1
 
             # Extract packages from commands for tracking
@@ -699,13 +730,13 @@ def install(
                     InstallationType.INSTALL, packages, commands, start_time
                 )
 
-            self._print_status("⚙️", f"Installing {software}...")
-            print("\nGenerated commands:")
+            self._print_status("⚙️", self.t("install.installing", package=software))
+            print(f"\n{self.t('install.generated_commands')}:")
             for i, cmd in enumerate(commands, 1):
                 print(f"  {i}. {cmd}")
 
             if dry_run:
-                print("\n(Dry run mode - commands not executed)")
+                print(f"\n({self.t('install.dry_run_note')})")
                 if install_id:
                     history.update_installation(install_id, InstallationStatus.SUCCESS)
                 return 0
@@ -1388,6 +1419,83 @@ def _env_load(self, env_mgr: EnvironmentManager, args: argparse.Namespace) -> in
 
         return 0
 
+    def config(self, args: argparse.Namespace) -> int:
+        """Handle CLI configuration commands.
+
+        Routes configuration subcommands to their respective handlers.
+        Currently supports language configuration via the 'language' subcommand.
+
+        Args:
+            args: Parsed CLI arguments containing config_action attribute
+                  and any subcommand-specific options.
+
+        Returns:
+            int: Exit code (0 on success, 1 on error or unknown subcommand).
+        """
+        config_action = getattr(args, "config_action", None)
+
+        if not config_action:
+            self._print_error("Please specify a subcommand (language)")
+            return 1
+
+        if config_action == "language":
+            return self._config_language(args)
+        else:
+            self._print_error(f"Unknown config subcommand: {config_action}")
+            return 1
+
+    def _config_language(self, args: argparse.Namespace) -> int:
+        """Handle language configuration."""
+        config_mgr = ConfigManager()
+        lang_mgr = LanguageManager()
+        new_language = getattr(args, "language_code", None)
+
+        # Load current preferences with error handling
+        try:
+            prefs = config_mgr.load_preferences()
+        except (OSError, ValueError) as e:
+            self._print_error(f"Failed to read configuration: {e}")
+            return 1
+
+        current_lang = prefs.get("language", "en")
+
+        if new_language:
+            # Resolve language (accepts codes like 'es' or names like 'Spanish', 'Español')
+            resolved = lang_mgr.resolve_language(new_language)
+            if not resolved:
+                self._print_error(f"Language '{new_language}' is not supported")
+                cx_print("Supported languages:", "info")
+                for code, name in lang_mgr.get_available_languages().items():
+                    console.print(f"  [green]{code}[/green] - {name}")
+                return 1
+
+            # Save preference with error handling
+            prefs["language"] = resolved
+            try:
+                config_mgr.save_preferences(prefs)
+            except (OSError, ValueError) as e:
+                self._print_error(f"Failed to save configuration: {e}")
+                return 1
+
+            lang_name = lang_mgr.get_language_name(resolved)
+            cx_print(f"✓ Language set to {lang_name} ({resolved})", "success")
+            cx_print("This will be used for all future Cortex commands.", "info")
+            return 0
+        else:
+            # Show current language and available options
+            lang_name = lang_mgr.get_language_name(current_lang)
+            cx_header("Language Configuration")
+            console.print(f"  Current language: [green]{lang_name}[/green] ({current_lang})")
+            console.print()
+            console.print("[bold]Available languages:[/bold]")
+            for code, name in sorted(lang_mgr.get_available_languages().items()):
+                marker = " [cyan]◄[/cyan]" if code == current_lang else ""
+                console.print(f"  [green]{code}[/green] - {name}{marker}")
+            console.print()
+            cx_print("Set language: cortex config language <code>", "info")
+            cx_print("Example: cortex config language es", "info")
+            return 0
+
     # --- Shell Environment Analyzer Commands ---
     def _env_audit(self, args: argparse.Namespace) -> int:
         """Audit shell environment variables and show their sources."""
@@ -2036,6 +2144,7 @@ def show_rich_help():
     table.add_row("rollback <id>", "Undo installation")
     table.add_row("notify", "Manage desktop notifications")
     table.add_row("env", "Manage environment variables")
+    table.add_row("config", "Configure Cortex settings")
     table.add_row("cache stats", "Show LLM cache statistics")
     table.add_row("stack <name>", "Install the stack")
     table.add_row("docker permissions", "Fix Docker bind-mount permissions")
@@ -2102,6 +2211,12 @@ def main():
     # Global flags
     parser.add_argument("--version", "-V", action="version", version=f"cortex {VERSION}")
     parser.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
+    parser.add_argument(
+        "--language",
+        "-L",
+        metavar="CODE",
+        help="Set display language for this command (e.g., en, es, de, ja)",
+    )
 
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
@@ -2220,6 +2335,18 @@ def main():
     cache_subs = cache_parser.add_subparsers(dest="cache_action", help="Cache actions")
     cache_subs.add_parser("stats", help="Show cache statistics")
 
+    # --- Configuration Commands ---
+    config_parser = subparsers.add_parser("config", help="Manage Cortex configuration")
+    config_subs = config_parser.add_subparsers(dest="config_action", help="Configuration actions")
+
+    # config language [code]
+    config_lang_parser = config_subs.add_parser("language", help="Get or set display language")
+    config_lang_parser.add_argument(
+        "language_code",
+        nargs="?",
+        help="Language code to set (e.g., en, es, fr, de, pt, ja, zh, ko, ar, hi, ru, it)",
+    )
+
     # --- Sandbox Commands (Docker-based package testing) ---
     sandbox_parser = subparsers.add_parser(
         "sandbox", help="Test packages in isolated Docker sandbox"
@@ -2486,7 +2613,7 @@ def main():
         return 0
 
     # Initialize the CLI handler
-    cli = CortexCLI(verbose=args.verbose)
+    cli = CortexCLI(verbose=args.verbose, language=args.language)
 
     try:
         # Route the command to the appropriate method inside the cli object
@@ -2531,6 +2658,8 @@ def main():
             return 1
         elif args.command == "env":
             return cli.env(args)
+        elif args.command == "config":
+            return cli.config(args)
         else:
             parser.print_help()
             return 1

cortex/config_manager.py

@@ -304,6 +304,31 @@ def _save_preferences(self, preferences: dict[str, Any]) -> None:
         except Exception as e:
             raise RuntimeError(f"Failed to save preferences: {e}")
 
+    def load_preferences(self) -> dict[str, Any]:
+        """
+        Load user preferences from ~/.cortex/preferences.yaml.
+
+        Public API for accessing user preferences.
+
+        Returns:
+            Dictionary of preferences (empty dict if none exist)
+        """
+        return self._load_preferences()
+
+    def save_preferences(self, preferences: dict[str, Any]) -> None:
+        """
+        Save user preferences to ~/.cortex/preferences.yaml.
+
+        Public API for persisting user preferences.
+
+        Args:
+            preferences: Dictionary of preferences to save
+
+        Raises:
+            RuntimeError: If preferences cannot be saved
+        """
+        self._save_preferences(preferences)
+
     def export_configuration(
         self,
         output_path: str,

cortex/i18n/__init__.py

@@ -0,0 +1,25 @@
+"""
+I18N Module Initialization
+
+Provides convenient access to i18n components for the rest of Cortex.
+
+Author: Cortex Linux Team
+License: Apache 2.0
+"""
+
+from cortex.i18n.fallback_handler import FallbackHandler, get_fallback_handler
+from cortex.i18n.language_manager import LanguageManager
+from cortex.i18n.pluralization import PluralRules
+from cortex.i18n.translator import Translator, get_translator, translate
+
+__all__ = [
+    "Translator",
+    "LanguageManager",
+    "PluralRules",
+    "FallbackHandler",
+    "get_translator",
+    "get_fallback_handler",
+    "translate",
+]
+
+__version__ = "0.1.0"