feat: création de la couche de services Core pour centraliser la logique métier

Author: raidos23

Core/Services/BuildService.py

@@ -0,0 +1,149 @@
+# 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.
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any, List, Optional
+
+from Core.Locking import BuildContext
+from Core.process_security import hardened_popen_kwargs, secure_command
+
+class BuildService:
+    """Business logic for compilation and build orchestration."""
+
+    @staticmethod
+    def run_engine_compile(
+        *,
+        workspace: Path,
+        engine_id: str,
+        context: BuildContext,
+        engine_config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        import EngineLoader as engines_loader
+
+        entry_path = workspace / Path(context.entry_point)
+        if not context.entry_point or not entry_path.is_file():
+            return {
+                "success": False,
+                "error": f"Entrypoint missing or obsolete: {context.entry_point}",
+            }
+
+        try:
+            engine = engines_loader.create(engine_id)
+        except Exception as exc:
+            return {"success": False, "error": f"Unable to load engine '{engine_id}': {exc}"}
+
+        try:
+            setattr(engine, "_config_overrides", dict(engine_config or {}))
+        except Exception:
+            pass
+
+        try:
+            resolved = engine.program_and_args_from_context(context)
+        except NotImplementedError:
+            return {
+                "success": False,
+                "error": f"Engine '{engine_id}' does not support BuildContext builds",
+            }
+        except Exception as exc:
+            return {
+                "success": False,
+                "error": f"Engine '{engine_id}' failed to build command: {exc}",
+            }
+        if not resolved:
+            return {"success": False, "error": f"Engine '{engine_id}' returned no command"}
+
+        program, args = resolved
+        try:
+            safe_program, safe_args, safe_env = secure_command(
+                program,
+                args,
+                {"ARK_WORKSPACE": str(workspace)},
+            )
+        except Exception as exc:
+            return {"success": False, "error": f"Unsafe compile command blocked: {exc}"}
+
+        try:
+            completed = subprocess.run(
+                [safe_program] + safe_args,
+                cwd=str(workspace),
+                env=safe_env,
+                capture_output=True,
+                text=True,
+                **hardened_popen_kwargs(),
+            )
+        except Exception as exc:
+            return {"success": False, "error": f"Compilation failed to start: {exc}"}
+
+        return {
+            "success": completed.returncode == 0,
+            "return_code": completed.returncode,
+            "command": [safe_program] + safe_args,
+            "stdout": completed.stdout,
+            "stderr": completed.stderr,
+            "error": None if completed.returncode == 0 else (completed.stderr.strip() or "Build failed"),
+        }
+
+    @staticmethod
+    def run_bcasl_headless(workspace_dir: str, timeout: float = 0.0) -> int:
+        ws_path = Path(workspace_dir)
+        if not ws_path.exists() or not ws_path.is_dir():
+            print(f"Invalid workspace: {workspace_dir}")
+            return 1
+
+        try:
+            from bcasl import run_pre_compile
+        except Exception as exc:
+            print(f"Unable to load BCASL module: {exc}")
+            return 1
+
+        if timeout > 0:
+            import os
+            os.environ["PYCOMPILER_BCASL_PLUGIN_TIMEOUT"] = str(timeout)
+
+        class _CliLogger:
+            def append(self, msg: str):
+                if not msg.endswith("\n"):
+                    msg += "\n"
+                print(f"[BCASL] {msg}", end="")
+
+        class _CliContext:
+            def __init__(self, ws_dir):
+                self.workspace_dir = ws_dir
+                self.log = _CliLogger()
+
+        try:
+            report = run_pre_compile(_CliContext(str(ws_path)))
+        except Exception as exc:
+            print(f"Failed to initialize BCASL mode: {exc}")
+            return 1
+
+        if report is None:
+            print("BCASL execution failed to start.")
+            return 1
+        if report.ok:
+            print("BCASL run completed successfully.")
+            return 0
+        
+        # Accessing failures if it's a list-like report
+        try:
+            failed = sum(1 for item in report if not item.success)
+        except Exception:
+            failed = 1
+            
+        print(f"BCASL run finished with failures: {failed} plugin(s) failed.")
+        return 1

Core/Services/ConfigService.py

@@ -0,0 +1,88 @@
+# 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.
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CONFIG_KEYS = {
+    "user-engine-dir": "user_engine_dir",
+    "user-plugin-dir": "user_plugin_dir",
+    "dev-engine-dir": "dev_engine_dir",
+    "dev-plugin-dir": "dev_plugin_dir",
+}
+
+DEFAULT_USER_DIRS = {
+    "user-engine-dir": ("ark_user", "engines"),
+    "user-plugin-dir": ("ark_user", "plugins"),
+}
+
+class ConfigService:
+    """Business logic for global ARK configuration."""
+
+    @staticmethod
+    def config_home() -> Path:
+        override = os.environ.get("ARK_CONFIG_HOME")
+        if override:
+            return Path(override).expanduser()
+        return Path.home() / ".arkconf"
+
+    @staticmethod
+    def ensure_config_home(*, create: bool = True) -> Path:
+        root = ConfigService.config_home()
+        if create:
+            root.mkdir(parents=True, exist_ok=True)
+        return root
+
+    @staticmethod
+    def config_file_for(key: str, *, create_root: bool = True) -> Path:
+        if key not in CONFIG_KEYS:
+            raise ValueError(f"Unknown config key: {key}")
+        return ConfigService.ensure_config_home(create=create_root) / CONFIG_KEYS[key]
+
+    @staticmethod
+    def resolve_config_value(key: str, *, create_default: bool = True) -> str | None:
+        path = ConfigService.config_file_for(key, create_root=False)
+        if path.exists():
+            value = path.read_text(encoding="utf-8").strip()
+            return value or None
+
+        default_parts = DEFAULT_USER_DIRS.get(key)
+        if not default_parts:
+            return None
+
+        default_path = Path.home().joinpath(*default_parts)
+        if create_default:
+            try:
+                default_path.mkdir(parents=True, exist_ok=True)
+            except OSError:
+                pass
+        return str(default_path)
+
+    @staticmethod
+    def set_config_value(key: str, value: str) -> str:
+        path = ConfigService.config_file_for(key, create_root=True)
+        target = str(Path(value).expanduser().resolve())
+        path.write_text(target + "\n", encoding="utf-8")
+        return target
+
+    @staticmethod
+    def unset_config_value(key: str) -> bool:
+        path = ConfigService.config_file_for(key)
+        if not path.exists():
+            return False
+        path.unlink()
+        return True

Core/Services/EngineConfigService.py

@@ -0,0 +1,103 @@
+# 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.
+
+"""
+EngineConfigService
+
+Business logic for persisting engine configuration per workspace at:
+  <workspace>/.ark/<engine_id>/config.json
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+ENGINE_CONFIG_DIRNAME = ".ark"
+ENGINE_CONFIG_BASENAME = "config.json"
+ENGINE_CONFIG_VERSION = 1
+
+class EngineConfigService:
+    @staticmethod
+    def _safe_engine_id(engine_id: str) -> str:
+        try:
+            raw = str(engine_id or "").strip()
+            safe = re.sub(r"[^A-Za-z0-9._-]+", "_", raw)
+            return safe or "engine"
+        except Exception:
+            return "engine"
+
+    @staticmethod
+    def _engine_config_dir(workspace_dir: str, engine_id: str) -> str:
+        return os.path.join(
+            workspace_dir, ENGINE_CONFIG_DIRNAME, EngineConfigService._safe_engine_id(engine_id)
+        )
+
+    @staticmethod
+    def _engine_config_path(workspace_dir: str, engine_id: str) -> str:
+        return os.path.join(
+            EngineConfigService._engine_config_dir(workspace_dir, engine_id), ENGINE_CONFIG_BASENAME
+        )
+
+    @staticmethod
+    def _atomic_write_json(path: str, data: dict) -> None:
+        tmp = path + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4)
+        os.replace(tmp, path)
+
+    @staticmethod
+    def load_engine_config(workspace_dir: str, engine_id: str) -> dict[str, Any]:
+        if not workspace_dir or not engine_id:
+            return {}
+        path = EngineConfigService._engine_config_path(workspace_dir, engine_id)
+        if not os.path.isfile(path):
+            return {}
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+            return data if isinstance(data, dict) else {}
+        except Exception:
+            return {}
+
+    @staticmethod
+    def save_engine_config(
+        workspace_dir: str,
+        engine_id: str,
+        options: Optional[dict],
+        engine_version: Optional[str] = None,
+    ) -> bool:
+        if not workspace_dir or not engine_id:
+            return False
+        try:
+            cfg_dir = EngineConfigService._engine_config_dir(workspace_dir, engine_id)
+            os.makedirs(cfg_dir, exist_ok=True)
+            payload = {
+                "meta": {
+                    "engine_id": str(engine_id),
+                    "version": ENGINE_CONFIG_VERSION,
+                    "updated_at": datetime.now(timezone.utc).isoformat(),
+                },
+                "options": options if isinstance(options, dict) else {},
+            }
+            if engine_version:
+                payload["meta"]["engine_version"] = str(engine_version)
+            EngineConfigService._atomic_write_json(EngineConfigService._engine_config_path(workspace_dir, engine_id), payload)
+            return True
+        except Exception:
+            return False