Refactor configuration management by merging Core.ArkConfig and Core.UserConfig into Core.Configs

- Introduced Core.Configs as a unified configuration module for PyCompiler ARK.
- Merged workspace/project configuration and user-level persistent settings into a single package.
- Updated all relevant imports across the codebase to reflect the new configuration structure.
- Added backward-compatibility shims in Core.ArkConfig and Core.UserConfig to ensure existing code continues to function.
- Implemented new engine runner functionality in Core.Compiler.engine_runner for better compilation command resolution and execution.
- Enhanced MainProcess to support compilation from a BuildContext, delegating to the new engine runner.
- Updated various modules and tests to accommodate the refactored configuration and engine execution logic.

Author: raidos23

Core/ArkConfig/__init__.py

@@ -62,6 +62,13 @@
     get_process_info,
 )
 
+from Core.Compiler.engine_runner import (
+    BuildContext,
+    EngineRunnerError,
+    resolve_engine_command,
+    run_engine_compile,
+)
+
 from EngineLoader.registry import get_engine, create
 
 __all__ = [
@@ -86,6 +93,11 @@
     "kill_process",
     "kill_process_tree",
     "get_process_info",
+    # engine_runner.py — source of truth for compilation
+    "BuildContext",
+    "EngineRunnerError",
+    "resolve_engine_command",
+    "run_engine_compile",
     # Business orchestration helpers (used by Ui/Gui/Dialogs/CompilerDialog.py)
     "_get_main_process",
     "_resolve_default_engine_id",

Core/Compiler/__init__.py

@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Engine Runner — pure-Python, Qt-free compilation executor.
+
+Source of truth for how ARK loads an engine and runs a compilation
+against a BuildContext.  Both the CLI (Ui/Cli/spec_helpers.py) and the
+Qt async path (MainProcess.compile_from_context) delegate to this module.
+
+Provides:
+- `resolve_engine_command` — load an engine and derive (program, args)
+- `run_engine_compile`     — full synchronous compilation pipeline
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from Core.process_security import hardened_popen_kwargs, secure_command
+
+# BuildContext lives in engine_sdk; imported here so callers of this module
+# only need to import from Core.Compiler.
+from engine_sdk.build_context import BuildContext
+
+
+class EngineRunnerError(RuntimeError):
+    """Raised when an engine cannot be loaded or does not produce a command."""
+
+
+def resolve_engine_command(
+    engine_id: str,
+    context: BuildContext,
+    engine_config: dict[str, Any] | None = None,
+) -> tuple[str, list[str]]:
+    """
+    Load *engine_id* and derive the (program, args) pair for *context*.
+
+    Args:
+        engine_id:     Registered engine identifier (e.g. ``"pyinstaller"``).
+        context:       BuildContext describing the project.
+        engine_config: Optional per-engine config overrides.
+
+    Returns:
+        A ``(program, args)`` tuple ready to be passed to subprocess.
+
+    Raises:
+        EngineRunnerError: When the engine cannot be loaded, does not support
+                           BuildContext builds, or returns an empty command.
+    """
+    try:
+        import EngineLoader as engines_loader
+        engine = engines_loader.create(engine_id)
+    except Exception as exc:
+        raise EngineRunnerError(
+            f"Unable to load engine '{engine_id}': {exc}"
+        ) from exc
+
+    try:
+        setattr(engine, "_config_overrides", dict(engine_config or {}))
+    except Exception:
+        pass
+
+    try:
+        resolved = engine.program_and_args_from_context(context)
+    except NotImplementedError as exc:
+        raise EngineRunnerError(
+            f"Engine '{engine_id}' does not support BuildContext builds"
+        ) from exc
+    except Exception as exc:
+        raise EngineRunnerError(
+            f"Engine '{engine_id}' failed to build command: {exc}"
+        ) from exc
+
+    if not resolved:
+        raise EngineRunnerError(f"Engine '{engine_id}' returned no command")
+
+    program, args = resolved
+    return str(program), list(args)
+
+
+def run_engine_compile(
+    *,
+    workspace: Path,
+    engine_id: str,
+    context: BuildContext,
+    engine_config: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """
+    Execute a compilation synchronously.
+
+    This is the **source of truth** for ARK's compilation pipeline.
+    It validates the entry point, resolves the command via the engine,
+    applies security hardening, and runs the subprocess.
+
+    Args:
+        workspace:     Absolute path to the project workspace.
+        engine_id:     Registered engine identifier.
+        context:       BuildContext describing the project.
+        engine_config: Optional per-engine config overrides (forwarded to
+                       ``engine._config_overrides``).
+
+    Returns:
+        A result dict with the following keys:
+
+        ``success`` (bool)
+            Whether ``returncode == 0``.
+        ``return_code`` (int | None)
+            Process return code, or ``None`` when the process never started.
+        ``command`` (list[str] | None)
+            The resolved, security-hardened command list, or ``None`` on early
+            failure.
+        ``stdout`` (str | None)
+            Captured standard output.
+        ``stderr`` (str | None)
+            Captured standard error.
+        ``error`` (str | None)
+            Human-readable error message, or ``None`` on success.
+    """
+    # ── 1. Validate entry point ──────────────────────────────────────────────
+    entry_path = workspace / Path(context.entry_point)
+    if not context.entry_point or not entry_path.is_file():
+        return _failure(
+            f"Entrypoint missing or obsolete: {context.entry_point}"
+        )
+
+    # ── 2. Resolve (program, args) from engine ───────────────────────────────
+    try:
+        program, args = resolve_engine_command(engine_id, context, engine_config)
+    except EngineRunnerError as exc:
+        return _failure(str(exc))
+
+    # ── 3. Security hardening ────────────────────────────────────────────────
+    try:
+        safe_program, safe_args, safe_env = secure_command(
+            program, args, {"ARK_WORKSPACE": str(workspace)}
+        )
+    except Exception as exc:
+        return _failure(f"Unsafe compile command blocked: {exc}")
+
+    # ── 4. Run ───────────────────────────────────────────────────────────────
+    command = [safe_program] + safe_args
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=str(workspace),
+            env=safe_env,
+            capture_output=True,
+            text=True,
+            **hardened_popen_kwargs(),
+        )
+    except Exception as exc:
+        return {
+            "success": False,
+            "return_code": None,
+            "command": command,
+            "stdout": None,
+            "stderr": None,
+            "error": f"Compilation failed to start: {exc}",
+        }
+
+    return {
+        "success": completed.returncode == 0,
+        "return_code": completed.returncode,
+        "command": command,
+        "stdout": completed.stdout,
+        "stderr": completed.stderr,
+        "error": (
+            None
+            if completed.returncode == 0
+            else (completed.stderr.strip() or "Build failed")
+        ),
+    }
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _failure(error: str) -> dict[str, Any]:
+    return {
+        "success": False,
+        "return_code": None,
+        "command": None,
+        "stdout": None,
+        "stderr": None,
+        "error": error,
+    }
+
+
+__all__ = [
+    "BuildContext",
+    "EngineRunnerError",
+    "resolve_engine_command",
+    "run_engine_compile",
+]

Core/Compiler/engine_runner.py

@@ -33,6 +33,7 @@
 import subprocess
 import shlex
 import re
+from pathlib import Path
 from typing import Optional, Dict, Any, List, Tuple
 from enum import Enum
 
@@ -44,12 +45,18 @@
 )
 
 # Importations ArkConfig pour la gestion des exclusions
-from Core.ArkConfig import (
+from Core.Configs import (
     load_ark_config,
     should_exclude_file,
     DEFAULT_EXCLUSION_PATTERNS,
 )
 
+from Core.Compiler.engine_runner import (
+    resolve_engine_command,
+    EngineRunnerError,
+)
+from engine_sdk.build_context import BuildContext
+
 
 class ProcessState(Enum):
     """Possible states of the main process."""
@@ -389,6 +396,49 @@ def get_compilation_info(self) -> Dict[str, Any]:
             "duration": self.compiler.duration,
         }
 
+    def compile_from_context(
+        self,
+        workspace: Path | str,
+        engine_id: str,
+        context: BuildContext,
+        engine_config: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Start an async compilation from a :class:`BuildContext`.
+
+        Resolves ``(program, args)`` via the engine, then delegates to
+        :class:`CompilerCore` (Qt thread) for non-blocking execution.
+
+        Args:
+            workspace:     Absolute path to the project workspace.
+            engine_id:     Registered engine identifier.
+            context:       BuildContext describing the project.
+            engine_config: Optional per-engine config overrides.
+
+        Returns:
+            ``True`` if the compilation thread started successfully.
+        """
+        workspace = Path(workspace)
+
+        # Resolve command via engine (pure-Python, no Qt)
+        try:
+            program, args = resolve_engine_command(engine_id, context, engine_config)
+        except EngineRunnerError as exc:
+            self.log_message.emit("error", str(exc))
+            return False
+
+        env = {"ARK_WORKSPACE": str(workspace)}
+        file_path = str(workspace / context.entry_point)
+
+        return self.compile(
+            program=program,
+            args=args,
+            env=env,
+            engine_id=engine_id,
+            file_path=file_path,
+            workspace_dir=str(workspace),
+        )
+
     def reset(self) -> None:
         """Reset process state for a new compilation."""
         self._current_file = None