Renommage de la commande CLI en 'pycompiler-ark' et mise à jour de la terminologie vers 'PyCompiler ARK'

Author: raidos23

Ui/Cli/app.py

@@ -86,7 +86,7 @@ def _build_impl(
 ) -> int:
     if lock_file and engine_override:
         raise CliSpecError(
-            "--engine cannot be used with --lock\nIf you need a different engine, create a new lock with: ark build --engine <engine_id>"
+            "--engine cannot be used with --lock\nIf you need a different engine, create a new lock with: pycompiler-ark build --engine <engine_id>"
         )
 
     if not as_json and verbose:
@@ -214,8 +214,8 @@ def tr(self, fr, en):
     # Rebuild from lock
     if lock_file == "__default__":
         raise CliSpecError(
-            "Usage: ark build --lock <FILE_OR_LATEST>\n"
-            "Exemple: ark build --lock latest"
+            "Usage: pycompiler-ark build --lock <FILE_OR_LATEST>\n"
+            "Exemple: pycompiler-ark build --lock latest"
         )
 
     if lock_file == "latest":
@@ -335,9 +335,9 @@ def build_cli():
         raise RuntimeError("Click is not available")
 
     @click.group(context_settings={"help_option_names": ["-h", "--help"]})
-    @click.version_option(version=_resolve_version(), prog_name="ark")
+    @click.version_option(version=_resolve_version(), prog_name="pycompiler-ark")
     def cli():
-        """ARK command line interface."""
+        """PyCompiler ARK command line interface."""
 
     @cli.command("init")
     @click.option("--entry", required=True, type=str)
@@ -349,7 +349,7 @@ def cli():
     def init_cmd(
         entry, icon, with_venv, install_requirements, generate_requirements, as_json
     ):
-        """Initialize the current directory as an ARK workspace."""
+        """Initialize the current directory as a PyCompiler ARK workspace."""
         try:
             payload = init_workspace(
                 cwd=Path.cwd(),
@@ -423,24 +423,24 @@ def run_bcasl_cmd(list_plugins, verbose):
     @cli.command("gui")
     @click.option("--legacy", is_flag=True)
     def gui_cmd(legacy):
-        """Launch the ARK GUI."""
+        """Launch the PyCompiler ARK GUI."""
         if legacy:
             click.echo(
-                "LIMITATION: The classic GUI does not support full UI feature integration.\nFor full functionality, use 'ark gui'."
+                "LIMITATION: The classic GUI does not support full UI feature integration.\nFor full functionality, use 'pycompiler-ark gui'."
             )
         raise click.exceptions.Exit(launch_gui(legacy=legacy))
 
     @cli.group("set")
     def set_group():
-        """Set user-level ARK paths."""
+        """Set user-level PyCompiler ARK paths."""
 
     @cli.group("get")
     def get_group():
-        """Get user-level ARK paths."""
+        """Get user-level PyCompiler ARK paths."""
 
     @cli.group("unset")
     def unset_group():
-        """Unset user-level ARK paths."""
+        """Unset user-level PyCompiler ARK paths."""
 
     for key in (
         "user-engine-dir",
@@ -567,7 +567,7 @@ def main(argv: list[str] | None = None) -> int:
     install_runtime(_resolve_version(), enable_qt=should_enable_qt(args))
     try:
         cli = build_cli()
-        result = cli.main(args=args, prog_name="ark", standalone_mode=False)
+        result = cli.main(args=args, prog_name="pycompiler-ark", standalone_mode=False)
         return int(result) if isinstance(result, int) else 0
     except SystemExit as exc:
         return int(exc.code) if isinstance(exc.code, int) else 0

Ui/Cli/helpers.py

@@ -208,7 +208,7 @@ class CliSpecError(RuntimeError):
 
 
 @dataclass(slots=True)
-class ArkValidationResult:
+class PyCompilerArkValidationResult:
     config: dict[str, Any]
     warnings: list[str]
 
@@ -219,7 +219,7 @@ class ArkValidationResult:
 
 
 def config_home() -> Path:
-    """Return the ARK user config root (delegates to Core.Configs)."""
+    """Return the PyCompiler ARK user config root (delegates to Core.Configs)."""
     return _config_home()
 
 
@@ -304,7 +304,7 @@ def init_workspace(
     if install_requirements:
         if not requirements_path.exists():
             raise CliSpecError(
-                "requirements.txt not found. Run 'ark init --generate-requirements' first."
+                "requirements.txt not found. Run 'pycompiler-ark init --generate-requirements' first."
             )
         if not venv_path.exists():
             builder = venv.EnvBuilder(with_pip=True)
@@ -337,7 +337,7 @@ def load_ark_config(workspace: Path) -> dict[str, Any]:
         raise CliSpecError(str(exc)) from exc
 
 
-def validate_ark_config(workspace: Path, config: dict[str, Any]) -> ArkValidationResult:
+def validate_ark_config(workspace: Path, config: dict[str, Any]) -> PyCompilerArkValidationResult:
     result: ArkConfigValidationResult = _validate_ark_config(workspace, config)
     errors = list(result.errors)
     warnings = list(result.warnings)
@@ -355,7 +355,7 @@ def validate_ark_config(workspace: Path, config: dict[str, Any]) -> ArkValidatio
         joined = "\n".join(f"- {item}" for item in errors)
         raise CliSpecError(f"Invalid ark.yml\n{joined}")
 
-    return ArkValidationResult(config=result.config, warnings=warnings)
+    return PyCompilerArkValidationResult(config=result.config, warnings=warnings)
 
 
 def engine_version(engine_id: str) -> str:

Ui/Cli/runtime.py

@@ -253,7 +253,7 @@ def should_enable_qt(argv: list[str] | None) -> bool:
 
 
 def is_cli_mode() -> bool:
-    """True when ARK runs as a terminal CLI (no Qt UI for plugins/dialogs)."""
+    """True when PyCompiler ARK runs as a terminal CLI (no Qt UI for plugins/dialogs)."""
     try:
         v = os.environ.get("PYCOMPILER_CLI")
         if v is None:
@@ -275,7 +275,7 @@ def is_noninteractive() -> bool:
 
 
 def use_rich_dialogs() -> bool:
-    """Use Rich console dialogs instead of Qt message boxes."""
+    """Use Rich console dialogs instead of Qt message boxes (for PyCompiler ARK)."""
     return is_cli_mode() or is_noninteractive()
 
 

docs/ark_main_config.md

@@ -2,7 +2,7 @@
 
 This file defines the project settings used to build the normalized **BuildContext**. It lives at the workspace root and is created automatically when the workspace is first configured in the GUI, if missing.
 
-The configuration is loaded by `Core/Configs/` and is the primary source of truth for project metadata.
+The configuration is loaded by `Core/Configs/` and is the primary source of truth for PyCompiler ARK project metadata.
 
 ## Minimal Example
 
@@ -75,4 +75,4 @@ If `bcasl_enabled` is set to `false`, the entire pipeline is skipped during comp
 
 ## 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.
+The main GUI has a **Configurations avancées** button that opens a dedicated editor for `ark.yml`, `bcasl.yml`, and other configuration files managed by PyCompiler ARK.

docs/contributing.md

@@ -1,10 +1,10 @@
 # **Contributing to PyCompiler ARK**
 
-Thank you for your interest in contributing to ARK! This workshop is designed to be extensible through its multi-engine and pre-compile plugin systems.
+Thank you for your interest in contributing to PyCompiler ARK! This workshop is designed to be extensible through its multi-engine and pre-compile plugin systems.
 
 ## **Where to Start?**
 
-If you are a developer looking to extend ARK's functionality, please refer to the following guides:
+If you are a developer looking to extend PyCompiler ARK's functionality, please refer to the following guides:
 
 - **Creating a Compilation Engine**: [docs/how_to_create_an_engine.md](how_to_create_an_engine.md)
   Learn how to package and register a new compiler (e.g., Py2Exe, Docker).
@@ -13,11 +13,11 @@ If you are a developer looking to extend ARK's functionality, please refer to th
 
 ## **Technical Specifications**
 
-For a deeper dive into ARK's internal architecture, review our core specifications:
+For a deeper dive into PyCompiler ARK's internal architecture, review our core specifications:
 
 - **BuildContext Spec**: [docs/dev_docs/ARK_BuildContext_v1.0.md](dev_docs/ARK_BuildContext_v1.0.md)
-- **CLI Spec**: [docs/dev_docs/ARK_Cli_v1.2.md](dev_docs/ARK_Cli_v1.2.md)
-- **Locking Spec**: [docs/dev_docs/ARK_Locking_v1.2.md](dev_docs/ARK_Locking_v1.2.md)
+- **CLI Spec**: [docs/dev_docs/PyCompiler_ARK_Cli_v1.2.md](dev_docs/PyCompiler_ARK_Cli_v1.2.md)
+- **Locking Spec**: [docs/dev_docs/PyCompiler_ARK_Locking_v1.2.md](dev_docs/PyCompiler_ARK_Locking_v1.2.md)
 
 ## **Development Workflow**
 

docs/dev_docs/PyCompiler_ARK_Cli_v1.2.md

@@ -0,0 +1,165 @@
+# **PyCompiler ARK CLI Specification v1.2**
+
+This document defines the final, streamlined specification for the PyCompiler ARK Command Line Interface.
+
+---
+
+### **1. Philosophy**
+
+The CLI is designed to be simple, predictable, and headless-friendly.
+
+- **Unified Binary**: Use `pycompiler-ark` (or `python pycompiler_ark.py`).
+- **Explicit Commands**: No hidden magic; every action requires an explicit command.
+- **CLI-First**: All features accessible via GUI are also available via CLI.
+- **Reproducibility**: Guaranteed via functional locking comparison.
+
+---
+
+### **2. Final Commands**
+
+```bash
+# Workspace (User)
+pycompiler-ark init --entry <path> [--icon <path>] [--with-venv] [--install-requirements] [--generate-requirements]
+pycompiler-ark build
+pycompiler-ark build --engine <id>
+pycompiler-ark build --lock [file] 
+
+# Execution
+pycompiler-ark run bcasl 
+
+# GUI
+pycompiler-ark gui
+pycompiler-ark gui --legacy 
+
+# Configuration (Developer)
+pycompiler-ark set user-engine-dir <path>
+pycompiler-ark set user-plugin-dir <path>
+pycompiler-ark set dev-engine-dir <path>
+pycompiler-ark set dev-plugin-dir <path> 
+
+pycompiler-ark get user-engine-dir
+pycompiler-ark get user-plugin-dir
+pycompiler-ark get dev-engine-dir
+pycompiler-ark get dev-plugin-dir 
+
+pycompiler-ark unset user-engine-dir
+pycompiler-ark unset user-plugin-dir
+pycompiler-ark unset dev-engine-dir
+pycompiler-ark unset dev-plugin-dir 
+
+# Discovery
+pycompiler-ark list engines
+pycompiler-ark list plugins 
+
+# Scaffolding
+pycompiler-ark scaffold engine <name> [--path <dir>]
+pycompiler-ark scaffold plugin-bcasl <name> [--path <dir>]
+```
+
+---
+
+### **3. GUI Status**
+
+| GUI Mode | Command | Status |
+| :--- | :--- | :--- |
+| **IDE-like GUI** | `pycompiler-ark gui` | **Active** (Modern, full feature set) |
+| **Classic GUI** | `pycompiler-ark gui --legacy` | **Frozen** (Legacy maintenance only) |
+
+---
+
+### **4. Engine and Plugin Discovery**
+
+PyCompiler ARK loads components from multiple locations in order of priority:
+
+| Tier | Role | Default Location |
+| :--- | :--- | :--- |
+| **Dev** | Development | Optional (set via `pycompiler-ark set dev-*`) |
+| **User** | User-installed | `~/ark_user/` (created automatically) |
+| **Core** | Built-in engines | `ENGINES/` folder in installation root |
+
+**Priority**: `Dev > User > Core`
+
+---
+
+### **5. Configuration (~/.arkconf/)**
+
+Global user settings are stored in text files under `~/.arkconf/`:
+
+- `pref.json`: Global GUI and runtime preferences.
+- `user_engine_dir`: Path to user-installed engines.
+- `user_plugin_dir`: Path to user-installed BCASL plugins.
+- `dev_engine_dir`: Path to active engine development.
+- `dev_plugin_dir`: Path to active plugin development.
+
+---
+
+### **6. Workspace Structure (.ark/)**
+
+A initialized workspace contains a hidden `.ark/` directory:
+
+- `lock/`: Immutable build snapshots and `latest.lock.yml`.
+- `cache/`: Internal build cache and rebuild comparison data.
+- `build/`: Temporary engine build artifacts.
+- `logs/`: Compilation and pipeline execution logs.
+
+---
+
+### **7. Configuration (ark.yml)**
+
+The project configuration file:
+
+```yaml
+project:
+  name: my_app
+  version: 1.0.0
+  entry: src/main.py 
+
+workspace:
+  exclude:
+    - "**/__pycache__/**" 
+
+build:
+  engine: nuitka
+  output: dist/
+  exclude:
+    - "tests/**/*"
+  data:
+    - source: plugins/
+      destination: plugins/
+  icon: assets/icon.ico
+
+plugins:
+  bcasl_enabled: true
+```
+
+---
+
+### **8. Detailed Command Behavior**
+
+#### **`pycompiler-ark init --entry <path>`**
+
+Initializes the current directory as a PyCompiler ARK workspace.
+
+- **Requirement**: The directory must already exist.
+- **Validation**: `--entry` must point to a file, not a directory.
+
+#### **`pycompiler-ark build`**
+
+- **Default**: Validates `ark.yml` and builds using the configured engine.
+- **Engine Override**: `--engine <id>` uses a temporary engine without modifying `ark.yml`.
+- **Reproducible Rebuild**: `--lock [file]` rebuilds strictly from a lock file (default: `.ark/lock/latest.lock.yml`).
+  - **Git State**: Automatically verifies if the current branch and commit match the lock. Offers automatic checkout on Linux.
+  - **Integrity Check**: PyCompiler ARK generates a shadow lock from the rebuild environment and performs a **Functional Equivalence** comparison. Detailed diffs are displayed in case of mismatch.
+- **Constraint**: `--engine` and `--lock` cannot be used together.
+
+---
+
+### **9. Summary Rules**
+
+- **CLI1**: No interactive questions; behavior is strictly deterministic.
+- **CLI2**: `pycompiler-ark init` only operates on the current working directory.
+- **CLI3**: All build artifacts and metadata stay inside the workspace `.ark/` folder.
+- **CLI4**: Engines and plugins follow a clear `dev > user > core` priority.
+
+---
+*End of Specification v1.2*