feat: suppression stricte des logs parasites en mode non-verbose et animation BCASL

- Ajout d'une redirection sys.stdout/sys.stderr vers devnull pendant BCASL et la compilation.
- Silence du logger 'bcasl' (niveau ERROR) en mode normal.
- Propagation du mode silencieux aux processus sandbox via PYCOMPILER_QUIET.
- Ajout du spinner animé Rich pour la commande 'ark run bcasl'.
- Support de l'option --verbose pour toutes les commandes liées à BCASL.

Author: raidos23

Ui/Cli/app.py

@@ -306,7 +306,8 @@ def run_group():
     @click.option("--timeout", type=float)
     @click.option("--parallel", type=int)
     @click.option("--list-plugins", is_flag=True)
-    def run_bcasl_cmd(timeout, parallel, list_plugins):
+    @click.option("--verbose", "-v", is_flag=True)
+    def run_bcasl_cmd(timeout, parallel, list_plugins, verbose):
         """Run BCASL in headless mode for the current workspace."""
         args: list[str]
         if list_plugins:
@@ -316,7 +317,7 @@ def run_bcasl_cmd(timeout, parallel, list_plugins):
             if timeout is not None:
                 args.extend(["--timeout", str(timeout)])
         del parallel
-        raise click.exceptions.Exit(run_bcasl_headless(args))
+        raise click.exceptions.Exit(run_bcasl_headless(args, verbose=verbose))
 
     @cli.command("gui")
     @click.option("--legacy", is_flag=True)

Ui/Cli/helpers.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import logging
 import os
 import signal
 import subprocess
+import sys
 import threading
 import venv
+from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -13,6 +16,40 @@
 _CLI_CANCEL_EVENT = threading.Event()
 
 
+@contextmanager
+def _redirect_output(enabled: bool):
+    """Redirect stdout and stderr to devnull if enabled is True."""
+    if not enabled:
+        yield
+        return
+
+    # Set env var for child processes (e.g. BCASL sandbox workers)
+    os.environ["PYCOMPILER_QUIET"] = "1"
+    
+    # Silence 'bcasl' logger
+    bcasl_logger = logging.getLogger("bcasl")
+    old_level = bcasl_logger.level
+    # If not verbose, only show CRITICAL/ERROR if they happen during compilation
+    # but the user wants it really clean, so let's go with ERROR.
+    bcasl_logger.setLevel(logging.ERROR)
+    
+    # Some handlers might be bound to the original sys.stderr/stdout.
+    # We don't remove them to avoid side effects, but setting the level should be enough.
+
+    with open(os.devnull, "w") as fnull:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        try:
+            sys.stdout = fnull
+            sys.stderr = fnull
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            bcasl_logger.setLevel(old_level)
+            os.environ.pop("PYCOMPILER_QUIET", None)
+
+
 def _cli_sigint_handler(signum, frame):
     """Handle SIGINT (Ctrl+C) by setting the cancellation event."""
     _CLI_CANCEL_EVENT.set()
@@ -42,12 +79,16 @@ def run_engine_compile(
     def _on_stdout(line: str):
         captured_stdout.append(line)
         if verbose:
+            # We are inside the redirection if verbose is False, 
+            # but here verbose is False so we don't print.
+            # If verbose is True, we are NOT redirected.
             plain(line)
         elif status:
             clean = line.strip()
             if clean:
                 # Update status message if it's a high-level step or important progress
                 if any(x in clean for x in ("Etape", "->", "Execution", "Commande")):
+                    # We must use console.print or status.update which bypasses sys.stdout if rich is used
                     status.update(f"[cyan]{clean}[/cyan]")
 
     def _on_stderr(line: str):
@@ -61,15 +102,17 @@ def _on_stderr(line: str):
     old_handler = signal.signal(signal.SIGINT, _cli_sigint_handler)
 
     try:
-        result = run_engine_compile_streaming(
-            workspace=workspace,
-            engine_id=engine_id,
-            context=context,
-            engine_config=engine_config,
-            on_stdout=_on_stdout,
-            on_stderr=_on_stderr,
-            stop_signal=lambda: _CLI_CANCEL_EVENT.is_set(),
-        )
+        # Use redirection to catch any direct print() calls from engines or their dependencies
+        with _redirect_output(not verbose):
+            result = run_engine_compile_streaming(
+                workspace=workspace,
+                engine_id=engine_id,
+                context=context,
+                engine_config=engine_config,
+                on_stdout=_on_stdout,
+                on_stderr=_on_stderr,
+                stop_signal=lambda: _CLI_CANCEL_EVENT.is_set(),
+            )
     except Exception as exc:
         result = {
             "success": False,
@@ -466,7 +509,9 @@ def append(self, msg: str):
     old_handler = signal.signal(signal.SIGINT, _cli_sigint_handler)
 
     try:
-        report = run_pre_compile(host)
+        # Catch direct prints from BCASL plugins or loader
+        with _redirect_output(not verbose):
+            report = run_pre_compile(host)
     except Exception as exc:
         if status:
             status.stop()
@@ -497,11 +542,11 @@ def append(self, msg: str):
     return True
 
 
-def run_bcasl_headless(args: list[str]) -> int:
+def run_bcasl_headless(args: list[str], verbose: bool = False) -> int:
     """Run BCASL in headless mode for the current workspace."""
     from bcasl.Loader import run_pre_compile
 
-    from .output import error, success
+    from .output import error, success, log, info, get_console
 
     workspace = Path.cwd()
     if "run" in args:
@@ -519,21 +564,55 @@ def __init__(self, ws_dir: Path):
 
             class Logger:
                 def append(self, msg: str):
-                    print(msg, end="", flush=True)
+                    if verbose:
+                        log("BCASL", msg.rstrip())
 
             self.log = Logger()
 
     host = CliBcaslHost(workspace)
+    
+    console = get_console()
+    status = None
+    if not verbose and console:
+        status = console.status("[cyan]Verification BCASL (headless)...[/cyan]", spinner="dots")
+        status.start()
+        
+    if verbose:
+        info(f"Running BCASL headless in {workspace}...")
+        
+    # Register SIGINT handler
+    _CLI_CANCEL_EVENT.clear()
+    old_handler = signal.signal(signal.SIGINT, _cli_sigint_handler)
+
     try:
-        report = run_pre_compile(host)
+        with _redirect_output(not verbose):
+            report = run_pre_compile(host)
+        
+        if _CLI_CANCEL_EVENT.is_set():
+            if status:
+                status.stop()
+            error("BCASL annule par l'utilisateur (Ctrl+C).")
+            return 1
+            
         if report and hasattr(report, "ok") and not getattr(report, "ok"):
+            if status:
+                status.stop()
             error("\nBCASL found issues.")
             return 1
+            
+        if status:
+            status.stop()
         success("\nBCASL completed successfully.")
         return 0
     except Exception as exc:
+        if status:
+            status.stop()
         error(f"BCASL failed: {exc}")
         return 1
+    finally:
+        signal.signal(signal.SIGINT, old_handler)
+        if status:
+            status.stop()
 
 
 def launch_gui(*, legacy: bool = False) -> int:

bcasl/executor.py

@@ -954,22 +954,47 @@ def _plugin_worker(
 
     Renvoie un dict via la queue: {ok: bool, error: str, duration_ms: float}
     """
+    import logging as _logging
+    import os as _os
+    import sys as _sys
     import time as _time
     import traceback as _tb
     from pathlib import Path as _Path
 
-    _configure_worker_env(config)
-    _maybe_init_qt_app(config)
-    _enforce_sdk_progress()
-    _apply_resource_limits(config)
+    # Handle quiet mode for sandbox processes
+    _quiet = _os.environ.get("PYCOMPILER_QUIET") == "1"
+    _fnull = None
+    _old_stdout = None
+    _old_stderr = None
+    
+    if _quiet:
+        _fnull = open(_os.devnull, "w")
+        _old_stdout = _sys.stdout
+        _old_stderr = _sys.stderr
+        _sys.stdout = _fnull
+        _sys.stderr = _fnull
+        # Also silence 'bcasl' logger in the child process
+        _logging.getLogger("bcasl").setLevel(_logging.ERROR)
+
     try:
-        from bcasl import PreCompileContext as _PCC
-
-        plg = _load_plugin_instance(module_path, plugin_id, project_root, config)
-        ctx = _PCC(_Path(project_root), config=dict(config or {}))
-        t0 = _time.perf_counter()
-        plg.on_pre_compile(ctx)
-        dur = (_time.perf_counter() - t0) * 1000.0
-        q.put({"ok": True, "error": "", "duration_ms": dur})
-    except Exception:
-        q.put({"ok": False, "error": _tb.format_exc(), "duration_ms": 0.0})
+        _configure_worker_env(config)
+        _maybe_init_qt_app(config)
+        _enforce_sdk_progress()
+        _apply_resource_limits(config)
+        try:
+            from bcasl import PreCompileContext as _PCC
+
+            plg = _load_plugin_instance(module_path, plugin_id, project_root, config)
+            ctx = _PCC(_Path(project_root), config=dict(config or {}))
+            t0 = _time.perf_counter()
+            plg.on_pre_compile(ctx)
+            dur = (_time.perf_counter() - t0) * 1000.0
+            q.put({"ok": True, "error": "", "duration_ms": dur})
+        except Exception:
+            q.put({"ok": False, "error": _tb.format_exc(), "duration_ms": 0.0})
+    finally:
+        if _quiet:
+            _sys.stdout = _old_stdout
+            _sys.stderr = _old_stderr
+            if _fnull:
+                _fnull.close()