Initial public release v0.1.0 - Linux Wabbajack Modlist Application

Jackify provides native Linux support for Wabbajack modlist installation
   and management with automated Steam integration and Proton configuration.

   Key Features:
   - Almost Native Linux implementation (texconv.exe run via proton)
   - Automated Steam shortcut creation and Proton prefix management
   - Both CLI and GUI interfaces, with Steam Deck optimization

   Supported Games:
   - Skyrim Special Edition
   - Fallout 4
   - Fallout New Vegas
   - Oblivion, Starfield, Enderal, and diverse other games

   Technical Architecture:
   - Clean separation between frontend and backend services
   - Powered by jackify-engine 0.3.x for Wabbajack-matching modlist installation

jackify/frontends/cli/commands/configure_modlist.py

@@ -0,0 +1,159 @@
+"""
+Configure Modlist Command
+
+CLI command for configuring a modlist post-install.
+Extracted from the original jackify-cli.py.
+"""
+
+import os
+import logging
+from typing import Optional
+
+# Import the backend services we'll need
+from jackify.backend.models.configuration import ConfigurationContext
+from jackify.shared.colors import COLOR_INFO, COLOR_ERROR, COLOR_RESET
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigureModlistCommand:
+    """Handler for the configure-modlist CLI command."""
+    
+    def __init__(self, backend_services):
+        """Initialize with backend services.
+        
+        Args:
+            backend_services: Dictionary of backend service instances
+        """
+        self.backend_services = backend_services
+        self.test_mode = False  # TODO: Get from global config
+    
+    def add_parser(self, subparsers):
+        """Add the configure-modlist subcommand parser.
+        
+        Args:
+            subparsers: The ArgumentParser subparsers object
+        """
+        configure_modlist_parser = subparsers.add_parser(
+            "configure-modlist", 
+            help="Configure a modlist post-install (for GUI integration)"
+        )
+        configure_modlist_parser.add_argument(
+            "--modlist-name", 
+            type=str, 
+            required=True, 
+            help="Name of the modlist to configure (Steam shortcut name)"
+        )
+        configure_modlist_parser.add_argument(
+            "--install-dir", 
+            type=str, 
+            required=True, 
+            help="Install directory of the modlist"
+        )
+        configure_modlist_parser.add_argument(
+            "--download-dir", 
+            type=str, 
+            help="Downloads directory (optional)"
+        )
+        configure_modlist_parser.add_argument(
+            "--nexus-api-key", 
+            type=str, 
+            help="Nexus API key (optional)"
+        )
+        configure_modlist_parser.add_argument(
+            "--mo2-exe-path", 
+            type=str, 
+            help="Path to ModOrganizer.exe (for AppID lookup)"
+        )
+        configure_modlist_parser.add_argument(
+            "--resolution", 
+            type=str, 
+            help="Resolution to set (optional)"
+        )
+        configure_modlist_parser.add_argument(
+            "--skip-confirmation", 
+            action='store_true', 
+            help="Skip confirmation prompts"
+        )
+        return configure_modlist_parser
+    
+    def execute(self, args) -> int:
+        """Execute the configure-modlist command.
+        
+        Args:
+            args: Parsed command-line arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for failure)
+        """
+        logger.info("Starting non-interactive modlist configuration (CLI mode)")
+        
+        try:
+            # Build configuration context from args
+            context = self._build_context_from_args(args)
+            
+            # Use legacy implementation for now - will migrate to backend services later
+            result = self._execute_legacy_configuration(context)
+            
+            logger.info("Finished non-interactive modlist configuration")
+            return 0 if result is not True else 1
+            
+        except Exception as e:
+            logger.error(f"Failed to configure modlist: {e}")
+            print(f"{COLOR_ERROR}Configuration failed: {e}{COLOR_RESET}")
+            return 1
+    
+    def _build_context_from_args(self, args) -> dict:
+        """Build context dictionary from command arguments.
+        
+        Args:
+            args: Parsed command-line arguments
+            
+        Returns:
+            Context dictionary
+        """
+        return {
+            'modlist_name': getattr(args, 'modlist_name', None),
+            'install_dir': getattr(args, 'install_dir', None),
+            'download_dir': getattr(args, 'download_dir', None),
+            'nexus_api_key': getattr(args, 'nexus_api_key', os.environ.get('NEXUS_API_KEY')),
+            'mo2_exe_path': getattr(args, 'mo2_exe_path', None),
+            'resolution': getattr(args, 'resolution', None),
+            'skip_confirmation': getattr(args, 'skip_confirmation', False),
+            'modlist_value': getattr(args, 'modlist_value', None),
+            'modlist_source': getattr(args, 'modlist_source', None),
+        }
+    
+    def _execute_legacy_configuration(self, context: dict):
+        """Execute configuration using legacy implementation.
+        
+        This is a temporary bridge - will be replaced with backend service calls.
+        
+        Args:
+            context: Configuration context dictionary
+            
+        Returns:
+            Result from legacy configuration
+        """
+        # Import backend services
+        from jackify.backend.handlers.menu_handler import ModlistMenuHandler
+        from jackify.backend.handlers.config_handler import ConfigHandler
+        
+        # Create legacy handler instances
+        config_handler = ConfigHandler()
+        modlist_menu = ModlistMenuHandler(
+            config_handler=config_handler,
+            test_mode=self.test_mode
+        )
+        
+        # Execute legacy configuration workflow
+        # The _configure_new_modlist method already handles Steam restart, manual steps, and configuration
+        result = modlist_menu._configure_new_modlist(
+            default_modlist_dir=context['install_dir'],
+            default_modlist_name=context['modlist_name']
+        )
+        
+        # The _configure_new_modlist method already calls run_modlist_configuration_phase internally
+        # So we don't need to call it again here
+        
+        return result