feat: ajout de la gestion globale de l'activation BCASL via ark.yml

- Ajout d'une case à cocher 'Activer BCASL' dans le dialogue du pipeline.
- Déplacement de la source de vérité de l'activation de bcasl.yml vers ark.yml (plugins.bcasl_enabled).
- Mise à jour du chargeur BCASL pour respecter la configuration ark.yml.
- Nettoyage automatique du champ 'enabled' dans bcasl.yml.
- Mise à jour de la documentation technique.

Author: raidos23

Ui/Gui/Dialogs/BcaslDialog.py

@@ -33,6 +33,8 @@
 
 import yaml
 
+from Core.Configs import load_ark_config, save_ark_config
+
 from PySide6.QtCore import Qt, Signal, QMimeData, QByteArray, QObject, QThread, Slot
 from PySide6.QtGui import QColor, QShortcut, QKeySequence, QPalette
 from PySide6.QtWidgets import (
@@ -488,6 +490,12 @@ def __init__(
         self._cfg = cfg
         self._plugin_instances = plugin_instances
 
+        # Charger la configuration ark.yml pour l'état d'activation global
+        try:
+            self._ark_cfg = load_ark_config(workspace_root)
+        except Exception:
+            self._ark_cfg = {}
+
         # Expert mode : liste mutable partagée avec les rows
         self._expert: list[bool] = [False]
 
@@ -521,6 +529,15 @@ def _build_ui(self) -> None:
         lbl.setTextFormat(Qt.RichText)
         title_row.addWidget(lbl)
         title_row.addStretch(1)
+
+        # Case à cocher pour l'activation globale (gérée par ark.yml)
+        self._chk_bcasl_enabled = QCheckBox(self._gui.tr("Activer BCASL", "Enable BCASL"))
+        self._chk_bcasl_enabled.setStyleSheet("font-weight: bold;")
+        bcasl_active = self._ark_cfg.get("plugins", {}).get("bcasl_enabled", True)
+        self._chk_bcasl_enabled.setChecked(bool(bcasl_active))
+        self._chk_bcasl_enabled.toggled.connect(self._on_bcasl_enabled_toggled)
+        title_row.addWidget(self._chk_bcasl_enabled)
+
         main.addLayout(title_row)
 
         # Tabs : Pipeline + onglets plugins
@@ -577,6 +594,17 @@ def _build_ui(self) -> None:
 
         main.addLayout(bottom)
 
+        # Initialiser l'état des onglets en fonction de l'activation
+        self._on_bcasl_enabled_toggled(self._chk_bcasl_enabled.isChecked())
+
+    def _on_bcasl_enabled_toggled(self, checked: bool) -> None:
+        """Active ou désactive les onglets de configuration selon l'état global."""
+        self._tabs.setEnabled(checked)
+        if not checked:
+            self._tabs.setToolTip(self._gui.tr("BCASL est désactivé dans ark.yml", "BCASL is disabled in ark.yml"))
+        else:
+            self._tabs.setToolTip("")
+
     def _populate_sections(self) -> None:
         """Grouper les plugins par section et les insérer."""
         plugins_raw = self._cfg.get("plugins", {}) if isinstance(self._cfg, dict) else {}
@@ -772,7 +800,20 @@ def _collect_plugin_configs(self) -> dict[str, dict]:
     def _do_save(self) -> None:
         plugin_configs = self._collect_plugin_configs()
 
-        # Construire la liste ordonnée de plugins
+        # 1) Sauvegarder l'état d'activation global dans ark.yml
+        try:
+            if "plugins" not in self._ark_cfg:
+                self._ark_cfg["plugins"] = {}
+            self._ark_cfg["plugins"]["bcasl_enabled"] = self._chk_bcasl_enabled.isChecked()
+            save_ark_config(str(self._workspace_root), self._ark_cfg)
+        except Exception as e:
+            QMessageBox.warning(
+                self,
+                self._gui.tr("Avertissement", "Warning"),
+                f"Impossible de mettre à jour ark.yml: {e}"
+            )
+
+        # 2) Construire la liste ordonnée de plugins pour bcasl.yml
         ordered: list[dict[str, Any]] = []
         for section in self._sections:
             for row in section.rows:
@@ -784,11 +825,15 @@ def _do_save(self) -> None:
                     "config": cfg_for_row,
                 })
 
-        # Construire la config de sortie
+        # Construire la config de sortie pour bcasl.yml
         cfg_out: dict[str, Any] = dict(self._cfg) if isinstance(self._cfg, dict) else {}
         cfg_out["plugins"] = _plugins_list_to_yaml(ordered)
         # plugin_order maintient la compatibilité avec l'ancien loader
         cfg_out["plugin_order"] = [e["name"] for e in ordered]
+        
+        # S'assurer que 'enabled' ne pollue plus bcasl.yml
+        if "options" in cfg_out and isinstance(cfg_out["options"], dict):
+            cfg_out["options"].pop("enabled", None)
 
         target = self._workspace_root / "bcasl.yml"
         try:

bcasl/Loader.py

@@ -33,6 +33,7 @@
 from typing import Any, Optional
 import yaml
 
+from Core.Configs import load_ark_config
 from .executor import BCASL
 
 from .Base import BcPluginBase, PreCompileContext
@@ -228,11 +229,11 @@ def _resolve_plugin_timeout(cfg: dict[str, Any]) -> float:
     return float(plugin_timeout) if plugin_timeout and plugin_timeout > 0 else 0.0
 
 
-def _is_bcasl_enabled(cfg: dict[str, Any]) -> bool:
-    """Return True si BCASL est activé dans la config."""
+def _is_bcasl_enabled(workspace_root: Path) -> bool:
+    """Consulte ark.yml pour savoir si le BCASL est activé globalement."""
     try:
-        opt = cfg.get("options", {}) if isinstance(cfg, dict) else {}
-        return bool(opt.get("enabled", True)) if isinstance(opt, dict) else True
+        ark_cfg = load_ark_config(workspace_root)
+        return bool(ark_cfg.get("plugins", {}).get("bcasl_enabled", True))
     except Exception:
         return True
 
@@ -420,7 +421,6 @@ def _read_yml(p: Path) -> dict[str, Any]:
             "venv/**",
             ".venv/**",
         ]
-        bcasl_enabled = True
         plugin_timeout = 0.0
 
         try:
@@ -435,8 +435,6 @@ def _read_yml(p: Path) -> dict[str, Any]:
                 exclude_patterns = ark_config["exclusion_patterns"]
 
             plugin_opts = ark_config.get("plugins", {})
-            if "bcasl_enabled" in plugin_opts:
-                bcasl_enabled = plugin_opts["bcasl_enabled"]
             if "plugin_timeout" in plugin_opts:
                 plugin_timeout = float(plugin_opts["plugin_timeout"])
         except Exception:
@@ -446,7 +444,6 @@ def _read_yml(p: Path) -> dict[str, Any]:
             "file_patterns": file_patterns,
             "exclude_patterns": exclude_patterns,
             "options": {
-                "enabled": bcasl_enabled,
                 "plugin_timeout_s": plugin_timeout,
                 "sandbox": True,
                 "plugin_parallelism": 0,
@@ -623,15 +620,14 @@ def run_pre_compile_async(self, on_done: Optional[callable] = None) -> None:
         cfg = _load_workspace_config(workspace_root)
         plugin_timeout = _resolve_plugin_timeout(cfg)
 
-        # Respect global enabled flag: skip BCASL when disabled
-        bcasl_enabled = _is_bcasl_enabled(cfg)
-        if not bcasl_enabled:
+        # Vérifier si BCASL est activé globalement via ark.yml
+        if not _is_bcasl_enabled(workspace_root):
             try:
                 if hasattr(self, "log") and self.log is not None:
                     self.log.append(
                         self.tr(
-                            "BCASL désactivé dans la configuration. Exécution ignorée\n",
-                            "BCASL disabled in configuration. Skipping execution\n",
+                            "BCASL désactivé dans ark.yml. Exécution ignorée\n",
+                            "BCASL disabled in ark.yml. Skipping execution\n",
                         )
                     )
             except Exception:
@@ -717,13 +713,12 @@ def run_pre_compile(self) -> Optional[object]:
         cfg = _load_workspace_config(workspace_root)
         plugin_timeout = _resolve_plugin_timeout(cfg)
 
-        # Respect global enabled flag: skip BCASL when disabled
-        bcasl_enabled = _is_bcasl_enabled(cfg)
-        if not bcasl_enabled:
+        # Vérifier si BCASL est activé globalement via ark.yml
+        if not _is_bcasl_enabled(workspace_root):
             try:
                 if hasattr(self, "log") and self.log is not None:
                     self.log.append(
-                        "BCASL désactivé dans la configuration. Exécution ignorée\n"
+                        "BCASL désactivé dans ark.yml. Exécution ignorée\n"
                     )
             except Exception:
                 pass

docs/ark_main_config.md

@@ -54,6 +54,17 @@ The fields in `ark.yml` are mapped directly to the `BuildContext` data structure
 | `build.data` | `data_mappings` |
 | `build.icon` | `icon` |
 
+## Plugins Configuration
+
+`ark.yml` controls the global activation of the **BCASL** (Before-Compilation Actions System) pipeline.
+
+```yaml
+plugins:
+  bcasl_enabled: true  # Global toggle for the BCASL pipeline
+```
+
+If `bcasl_enabled` is set to `false`, the entire pipeline is skipped during compilation. This setting is also manageable via the **BCASL Pipeline** dialog in the GUI.
+
 ## Advanced Config Editor (GUI)
 
 The main GUI has a **Configurations avancées** button that opens a dedicated editor for `ark.yml`, `bcasl.yml`, and other configuration files.

docs/how_to_create_a_bc_plugin.md

@@ -101,7 +101,6 @@ exclude_patterns:
 - "**/__pycache__/**"
 - "**/*.pyc"
 options:
-  enabled: true
   sandbox: true
   plugin_timeout_s: 5
   plugin_parallelism: 0
@@ -120,6 +119,7 @@ plugin_order:
 ```
 
 Important notes.
+- Global BCASL activation is managed by **`ark.yml`** (`plugins.bcasl_enabled`).
 - Keys in `plugins` are the `PluginMeta.id` values.
 - `plugin_order` forces ordering and adjusts priority.
 - If `bcasl.yml` is missing, a default file is generated.