Refactor engines to use required_tools property with dict format

`Update sys_deps to handle system package installation`

`Update engines to use new required_tools property`

Author: raidos23

Core/engines_loader/base.py

@@ -87,12 +87,59 @@ def should_compile_file(
         return True
 
     @property
-    def required_tools(self) -> list[str]:
+    def required_tools(self) -> dict[str, list[str]]:
         """
-        Return list of tool names required by this engine (e.g., ['pyinstaller'], ['nuitka']).
-        Used by VenvManager to check/install dependencies.
+        Return dict of required tools with installation modes.
+        Keys: 'python' for pip-installable tools, 'system' for system packages.
+        Used by VenvManager for Python tools and system installer for system tools.
+        Example: {'python': ['pyinstaller'], 'system': ['build-essential']}
         """
-        return []
+        return {'python': [], 'system': []}
+
+    def ensure_tools_installed(self, gui) -> bool:
+        """
+        Ensure all required tools are installed.
+        Returns True if all tools are ready, False if installation failed or was cancelled.
+        Handles both Python (pip) and system packages.
+        """
+        try:
+            tools = self.required_tools
+            python_tools = tools.get('python', [])
+            system_tools = tools.get('system', [])
+
+            # Check if VenvManager is available
+            if hasattr(gui, 'venv_manager') and gui.venv_manager:
+                venv_root = gui.venv_manager.resolve_project_venv()
+                if venv_root:
+                    # Install Python tools via VenvManager
+                    if python_tools:
+                        try:
+                            gui.venv_manager.ensure_tools_installed(venv_root, python_tools)
+                            # Wait for completion (simplified - in practice would need async handling)
+                        except Exception as e:
+                            if hasattr(gui, 'log') and gui.log:
+                                gui.log.append(f"⚠️ Failed to install Python tools {python_tools}: {e}")
+                            return False
+
+            # Install system tools
+            if system_tools:
+                try:
+                    from Core.sys_deps import install_system_packages
+                    success = install_system_packages(system_tools, gui)
+                    if not success:
+                        if hasattr(gui, 'log') and gui.log:
+                            gui.log.append(f"⚠️ Failed to install system tools {system_tools}")
+                        return False
+                except Exception as e:
+                    if hasattr(gui, 'log') and gui.log:
+                        gui.log.append(f"⚠️ Failed to install system tools {system_tools}: {e}")
+                    return False
+
+            return True
+        except Exception as e:
+            if hasattr(gui, 'log') and gui.log:
+                gui.log.append(f"⚠️ Error ensuring tools installed: {e}")
+            return False
 
     def get_log_prefix(self, file_basename: str) -> str:
         """

Core/sys_deps.py

@@ -918,3 +918,46 @@ def install_packages_linux(
             )
         except Exception:
             return None
+
+
+def install_system_packages(packages: list[str], gui) -> bool:
+    """
+    Install system packages using the appropriate package manager.
+    Returns True if successful, False otherwise.
+    """
+    try:
+        manager = SysDependencyManager(gui)
+        system = platform.system().lower()
+
+        if system == "linux":
+            # For Linux, use the install_packages_linux method
+            process = manager.install_packages_linux(packages)
+            if process:
+                # Wait for completion (simplified - in practice should be async)
+                process.waitForFinished(300000)  # 5 minutes timeout
+                return process.exitCode() == 0
+        elif system == "windows":
+            # For Windows, convert package names to winget format
+            # This is a simplified mapping - in practice would need proper mapping
+            winget_packages = []
+            for pkg in packages:
+                # Basic mapping - would need expansion for real use
+                if pkg == "build-essential":
+                    winget_packages.append({"id": "Microsoft.VisualStudio.2022.BuildTools"})
+                elif pkg == "python3-dev":
+                    winget_packages.append({"id": "Python.Python.3"})
+                else:
+                    # Generic fallback
+                    winget_packages.append({"id": pkg})
+
+            process = manager.install_packages_windows(winget_packages)
+            if process:
+                process.waitForFinished(300000)  # 5 minutes timeout
+                return process.exitCode() == 0
+        else:
+            # Unsupported platform
+            return False
+
+        return False
+    except Exception:
+        return False

ENGINES/cx_freeze/__init__.py

@@ -51,28 +51,16 @@ class CXFreezeEngine(CompilerEngine):
     required_sdk_version: str = "1.0.0"
 
     @property
-    def required_tools(self) -> list[str]:
-        return ["cx_freeze"]
+    def required_tools(self) -> dict[str, list[str]]:
+        """Return required tools for CX_Freeze compilation."""
+        return {
+            'python': ['cx_freeze'],
+            'system': []
+        }
 
     def preflight(self, gui, file: str) -> bool:
-        """Check if CX_Freeze is available in the venv."""
-        try:
-            venv_manager = getattr(gui, "venv_manager", None)
-            if not venv_manager:
-                return True  # Let build_command fail instead
-
-            venv_path = venv_manager.resolve_project_venv()
-            if not venv_path:
-                return True  # Let build_command fail instead
-
-            if not venv_manager.has_tool_binary(venv_path, "cx_freeze"):
-                # Try to install cx_freeze
-                venv_manager.ensure_tools_installed(venv_path, ["cx_freeze"])
-                return False  # Will be retried after installation
-
-            return True
-        except Exception:
-            return True  # Let build_command handle errors
+        """Preflight check - dependencies are handled automatically by required_tools."""
+        return True
 
     def build_command(self, gui, file: str) -> list[str]:
         """Build the CX_Freeze command line."""

ENGINES/nuitka/__init__.py

@@ -55,28 +55,26 @@ class NuitkaEngine(CompilerEngine):
     required_sdk_version: str = "1.0.0"
 
     @property
-    def required_tools(self) -> list[str]:
-        return ["nuitka"]
+    def required_tools(self) -> dict[str, list[str]]:
+        """Return required tools for Nuitka compilation."""
+        system_tools = []
+        if platform.system() == "Linux":
+            # patchelf is needed for Linux binary manipulation
+            # gcc is needed for compilation
+            system_tools = ["patchelf", "gcc"]
+        elif platform.system() == "Windows":
+            # On Windows, Visual Studio Build Tools or similar might be needed
+            # but we'll keep it minimal for now
+            system_tools = []
+
+        return {
+            'python': ['nuitka'],
+            'system': system_tools
+        }
 
     def preflight(self, gui, file: str) -> bool:
-        """Check if Nuitka is available in the venv."""
-        try:
-            venv_manager = getattr(gui, "venv_manager", None)
-            if not venv_manager:
-                return True  # Let build_command fail instead
-
-            venv_path = venv_manager.resolve_project_venv()
-            if not venv_path:
-                return True  # Let build_command fail instead
-
-            if not venv_manager.has_tool_binary(venv_path, "nuitka"):
-                # Try to install nuitka
-                venv_manager.ensure_tools_installed(venv_path, ["nuitka"])
-                return False  # Will be retried after installation
-
-            return True
-        except Exception:
-            return True  # Let build_command handle errors
+        """Preflight check - dependencies are handled automatically by required_tools."""
+        return True
 
     def build_command(self, gui, file: str) -> list[str]:
         """Build the Nuitka command line."""

ENGINES/pyinstaller/__init__.py

@@ -57,28 +57,16 @@ class PyInstallerEngine(CompilerEngine):
     required_sdk_version: str = "1.0.0"
 
     @property
-    def required_tools(self) -> list[str]:
-        return ["pyinstaller"]
+    def required_tools(self) -> dict[str, list[str]]:
+        """Return required tools for PyInstaller compilation."""
+        return {
+            'python': ['pyinstaller'],
+            'system': []
+        }
 
     def preflight(self, gui, file: str) -> bool:
-        """Check if PyInstaller is available in the venv."""
-        try:
-            venv_manager = getattr(gui, "venv_manager", None)
-            if not venv_manager:
-                return True  # Let build_command fail instead
-
-            venv_path = venv_manager.resolve_project_venv()
-            if not venv_path:
-                return True  # Let build_command fail instead
-
-            if not venv_manager.has_tool_binary(venv_path, "pyinstaller"):
-                # Try to install pyinstaller
-                venv_manager.ensure_tools_installed(venv_path, ["pyinstaller"])
-                return False  # Will be retried after installation
-
-            return True
-        except Exception:
-            return True  # Let build_command handle errors
+        """Preflight check - dependencies are handled automatically by required_tools."""
+        return True
 
     def build_command(self, gui, file: str) -> list[str]:
         """Build the PyInstaller command line."""