arclith-cli 0.12.0__tar.gz → 0.14.0__tar.gz

{arclith_cli-0.12.0 → arclith_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: arclith-cli
-Version: 0.12.0
+Version: 0.14.0
 Summary: CLI scaffolding tool for arclith — hexagonal architecture framework
 Author-email: Killian KOPP <killiankopp@gmail.com>
 License:                                  Apache License
@@ -186,7 +186,7 @@ License:                                  Apache License
 License-File: LICENSE
 Keywords: arclith,cli,ddd,hexagonal-architecture,scaffold
 Requires-Python: >=3.13
-Requires-Dist: arclith>=0.15.0
+Requires-Dist: arclith>=0.17.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{arclith_cli-0.12.0 → arclith_cli-0.14.0}/README.md

@@ -13,7 +13,8 @@ uv tool install "git+https://github.com/karned-rekipe/arclith.git#subdirectory=c
 ### `init` — Initialiser un projet minimal
 
 Crée un projet Arclith vide de métier, avec le layout canonique `src/<package>/...`, une
-configuration minimale et un `main.py` prêt à recevoir les adapters.
+configuration minimale, un `main.py` prêt à recevoir les adapters et le runtime Docker standard
+(`Dockerfile`, `.dockerignore`, `arclith-run`).
 
 ```bash
 # Mode interactif
@@ -49,7 +50,9 @@ arclith-cli new MealPlan meal-plan-service --dir ~/projects --port 8500
 | `--dir` / `-d` | `.` | Répertoire parent |
 | `--ref` | `main` | Branche/tag du template |
 
-Le projet généré utilise un layout `src/<package>/...` pour le code applicatif et un dossier `config/` structuré par adapter (voir section [Configuration](#configuration)).
+Le projet généré utilise un layout `src/<package>/...` pour le code applicatif et un dossier
+`config/` structuré par adapter (voir section [Configuration](#configuration)). Le Dockerfile du
+template est régénéré côté CLI pour appliquer le contrat `runtime/docker-image` courant.
 
 ---
 
@@ -132,42 +135,50 @@ arclith-cli add-adapter
 Mode direct, utile pour CI, scripts de migration ou commandes reproductibles :
 
 ```bash
-arclith-cli add-adapter --adapter mongodb --entity Recipe --db-name my_recipe_service --yes
+arclith-cli add-adapter --adapter mongodb --entity Recipe --db-name my_recipe_service --param collection_name=recipes --yes
 arclith-cli add-adapter --adapter duckdb --all-entities --path data/ --no-activate --yes
 arclith-cli add-adapter --adapter mariadb --entity Recipe --param database=my_recipe_service --param user=app --yes
 arclith-cli add-adapter --capability api --adapter fastapi --param port=8080 --yes
 arclith-cli add-adapter --capability mcp --adapter fastmcp --param port=8081 --yes
 arclith-cli add-adapter --capability llm --adapter lmstudio --param model_name=qwen/qwen3.5-9b --yes
-arclith-cli add-adapter --capability agent --adapter langgraph --param graph_name=recipe_agent --yes
+arclith-cli add-adapter --capability agent --adapter langgraph --param graph_name=recipe_agent --param stream_mode=updates,custom --yes
 arclith-cli add-adapter --capability observability --adapter langsmith
 arclith-cli add-adapter --capability observability --adapter opentelemetry --param service_name=my_recipe_service --yes
+arclith-cli add-adapter --capability runtime --adapter docker-image --yes
+arclith-cli add-adapter --capability cache --adapter memory --yes
+arclith-cli add-adapter --capability cache --adapter redis --param redis_url=redis://redis:6379 --yes
 arclith-cli add-adapter --capability repository --adapter memory --entity Recipe --yes
 ```
 
 **Étapes du wizard :**
 
-1. **Type d'adapter** — selon la capacité : `memory` · `mongodb` · `duckdb` · `mariadb` · `fastapi` · `fastmcp` · `lmstudio` · `openai` · `anthropic` · `langgraph` · `langsmith` · `opentelemetry`
-2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour les transports globaux, `llm/*`, `agent/langgraph` et les adapters d'observability
+1. **Type d'adapter** — selon la capacité : `memory` · `mongodb` · `duckdb` · `mariadb` · `fastapi` · `fastmcp` · `rabbitmq` · `docker-image` · `lmstudio` · `openai` · `anthropic` · `langgraph` · `langsmith` · `opentelemetry`
+2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour les transports globaux, `cache/*`, `llm/*`, `agent/langgraph`, `runtime/docker-image` et les adapters d'observability
 3. **Paramètres** — questions spécifiques à l'adapter :
-   - `mongodb` → `db_name`, `multitenant`
+   - `mongodb` → `db_name`, `collection_name`, `multitenant`
    - `duckdb` → `path`
    - `mariadb` → `host`, `port`, `database`, `user`, `driver`, `table_prefix`
+     (`url` et `password` sont mappés via `config/secrets.yaml`)
+   - `cache/memory` → `jwks_ttl`, `tenant_uri_ttl`
+   - `cache/redis` → `redis_url`, `jwks_ttl`, `tenant_uri_ttl`
    - `fastapi` → `host`, `port`, `reload`
    - `fastmcp` → `host`, `port`
    - `lmstudio` → `model_name`, `base_url`, `api_key`
    - `openai` → `model_name`, `base_url`, `OPENAI_API_KEY`
    - `anthropic` → `model_name`, `ANTHROPIC_API_KEY`
-   - `langgraph` → `graph_name`
+   - `langgraph` → `graph_name`, `stream_mode`
    - `langsmith` → `tracing`, `project`, `endpoint`, `LANGSMITH_API_KEY`
-   - `opentelemetry` → `service_name`, `endpoint`, `protocol`, `traces`, `metrics`, `instrument_fastapi`
-   - `memory` → aucun paramètre
-4. **Activation** — met à jour `config/adapters/adapters.yaml` pour les capacités activables (`repository: <adapter>` ou `observability.enabled: [<adapter>, ...]`) ; `api/fastapi`, `mcp/fastmcp`, `llm/*` et `agent/langgraph` sont exposés par leurs fichiers de configuration scopés
+   - `opentelemetry` → `service_name`, `endpoint`, `traces_endpoint`, `metrics_endpoint`, `protocol`, `traces`, `metrics`, `instrument_fastapi`
+   - `command-bus/rabbitmq` → `url`, `exchange`, `exchange_type`, `queue`, `routing_key`, `prefetch`, `consumer_name`, `concurrency`, `publisher_confirms`, `durable`, `retry_enabled`, `retry_requeue`, `dead_letter_exchange`, `dead_letter_routing_key`
+   - `runtime/docker-image` → `uv_version`, `api_port`, `mcp_port`, `probe_port`, `agent_port`
+   - `repository/memory` → aucun paramètre
+4. **Activation** — met à jour `config/adapters/adapters.yaml` pour les capacités activables (`repository: <adapter>` ou `observability.enabled: [<adapter>, ...]`) ; `api/fastapi`, `mcp/fastmcp`, `cache/*`, `llm/*`, `agent/langgraph`, `command-bus/rabbitmq` et `runtime/docker-image` sont exposés par leurs fichiers dédiés
 5. **Récapitulatif** — liste des fichiers créés ou remplacés avant confirmation
 
 | Option | Défaut | Description |
 |--------|--------|-------------|
-| `--capability` | `repository` | Capacité cible du catalogue standardisé (`repository`, `api`, `mcp`, `llm`, `agent`, `observability`) |
-| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `fastapi`, `fastmcp`, `lmstudio`, `openai`, `anthropic`, `langgraph`, `langsmith`, `opentelemetry` |
+| `--capability` | `repository` | Capacité cible du catalogue standardisé (`repository`, `cache`, `api`, `mcp`, `http`, `command-bus`, `runtime`, `llm`, `agent`, `observability`) |
+| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `fastapi`, `fastmcp`, `idempotency`, `etag`, `cache-control`, `rabbitmq`, `docker-image`, `lmstudio`, `openai`, `anthropic`, `langgraph`, `langsmith`, `opentelemetry` |
 | `--entity` / `-e` | auto si une seule entité | Entité cible, liste séparée par virgule acceptée |
 | `--all-entities` | `false` | Génère l'adapter pour toutes les entités détectées |
 | `--activate/--no-activate` | `--activate` | Met à jour `config/adapters/adapters.yaml` quand la capacité expose une clé d'activation |
@@ -189,6 +200,20 @@ src/<package>/infrastructure/containers/<entity>_container.py  # RepositoryRegis
 
 > ⚠️ `src/<package>/infrastructure/containers/<entity>_container.py` est **régénéré intégralement** si le fichier existe déjà — un avertissement est affiché dans le récapitulatif.
 
+**Runtime Docker :**
+
+```bash
+arclith-cli add-adapter --capability runtime --adapter docker-image --yes
+uv lock
+docker build -t my-recipe-service:local .
+docker run --rm -p 8000:8000 -p 9000:9000 my-recipe-service:local api
+```
+
+L'adapter `runtime/docker-image` génère `Dockerfile`, `.dockerignore` et `arclith-run`. Une seule
+image peut démarrer `api`, `mcp_http`, `mcp_sse`, `bus`, `agent` ou `all` par argument ou via
+`ARCLITH_RUNTIME_MODE`. Les secrets restent hors build; `.env`, `secrets.yaml` et les clés privées
+sont exclus du contexte Docker.
+
 **LangGraph / LangSmith :**
 
 ```bash
@@ -200,13 +225,24 @@ uv run langgraph dev --no-browser --allow-blocking --port 2024
 ```
 
 L'adapter `llm/lmstudio` génère `config/adapters/outbound/lm.yaml`, chargé dans
-`AppConfig.adapters.lm`. Les adapters `llm/openai` et `llm/anthropic` génèrent aussi un mapping
-`config/secrets.yaml` vers `OPENAI_API_KEY` ou `ANTHROPIC_API_KEY`.
+`AppConfig.adapters.lm`. Adapter `model_name` au modèle chargé dans LM Studio et utiliser
+`host.docker.internal` comme `base_url` si le projet tourne dans Docker alors que LM Studio tourne
+sur l'hôte. Les adapters `llm/openai` et `llm/anthropic` génèrent aussi un mapping
+`config/secrets.yaml` vers `OPENAI_API_KEY` ou `ANTHROPIC_API_KEY`; la clé réelle reste dans `.env`
+local gitignoré, l'environnement runtime ou Vault.
+Utiliser `llm/anthropic` pour Claude via le provider Anthropic; utiliser `llm/openai` pour OpenAI,
+LM Studio ou tout endpoint OpenAI-compatible avec `base_url`.
+
+L'adapter `repository/mongodb` génère `config/adapters/outbound/mongodb.yaml` avec `uri: null`, puis
+mappe `adapters.mongodb.uri` vers `MONGODB_URI` dans `config/secrets.yaml`. L'URI réelle reste dans
+l'environnement, un fichier local de secrets ou Vault selon le resolver choisi.
 
 L'adapter `agent/langgraph` génère `langgraph.json`, `config/adapters/inbound/langgraph.yaml` et
 `src/<package>/adapters/inbound/langgraph/agent.py`. Le projet ne modifie ensuite que ce fichier pour
 son agent. Comme `fastapi` et `fastmcp`, LangGraph est configuré par son nom produit dans
-`AppConfig.langgraph`, sans `adapters.agent`. L'adapter `observability/langsmith` génère
+`AppConfig.langgraph`, sans `adapters.agent`. `stream_mode` vaut `updates` par défaut et accepte une
+liste CSV comme `updates,custom` pour exposer les sorties de nodes et les événements
+`get_stream_writer()`. L'adapter `observability/langsmith` génère
 `config/adapters/outbound/langsmith.yaml`, l'ajoute à `observability.enabled`, met
 à jour `.env` et ajoute `.env` au `.gitignore` si besoin. LangSmith Studio devient l'endroit standard
 pour tester les agents. Une `LANGSMITH_API_KEY` déjà présente est conservée si aucune nouvelle valeur
@@ -224,6 +260,9 @@ jour `.env`, l'ajoute à `observability.enabled` et branche l'instrumentation Fa
 `Arclith.fastapi()` construit l'application. Il peut être activé en même temps que LangSmith.
 Le fichier `opentelemetry.yaml` ne porte pas de flag `enabled`: l'activation se fait uniquement dans
 `observability.enabled`.
+L'endpoint global est utilisé par défaut; `traces_endpoint` et `metrics_endpoint` peuvent cibler des
+routes OTLP distinctes. Pour taguer l'environnement, définir
+`OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=local` dans l'environnement runtime.
 
 Parcours complet avec entité, API, LangGraph, LangSmith et LM Studio:
 [`docs/agent-quickstart.md`](../docs/agent-quickstart.md).
@@ -310,6 +349,19 @@ config/
       cache.yaml                  # cache: { backend, redis_url, … }
 ```
 
+`cache/memory` génère `config/adapters/inbound/cache.yaml` avec `backend: memory` et les TTL JWKS /
+tenant. Ce cache est strictement local au processus Python: il suffit pour le développement, les
+tests et un worker unique. Passer à Redis dès qu'il faut partager le cache entre plusieurs workers,
+réplicas, ou processus séparés API/MCP/agent.
+
+`cache/redis` génère le même fichier avec `backend: redis`, mappe `cache.redis_url` vers
+`REDIS_URL` dans `config/secrets.yaml` et écrit la valeur fournie dans `.env` local gitignoré.
+Installer l'extra avant de lancer le service:
+
+```bash
+uv add "arclith[cache]"
+```
+
 Pour changer l'adapter actif sans passer par le wizard :
 
 ```yaml
@@ -321,4 +373,6 @@ observability:
     - opentelemetry
 ```
 
-Pour MariaDB, ne committez pas le mot de passe. Mappez `adapters.mariadb.password` ou `adapters.mariadb.url` via `config/secrets.yaml`, un resolver `env` ou Vault.
+Pour MariaDB, ne committez pas le mot de passe ni l'URL complète si elle contient des identifiants.
+La CLI mappe `adapters.mariadb.password` vers `MARIADB_PASSWORD` et `adapters.mariadb.url` vers
+`MARIADB_URL` dans `config/secrets.yaml`; remplacer le resolver `env` par Vault selon l'environnement.

arclith_cli-0.14.0/arclith_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.14.0"

{arclith_cli-0.12.0 → arclith_cli-0.14.0}/arclith_cli/add_adapter.py

@@ -29,6 +29,7 @@ from .entity_scanner import EntityInfo, scan_entities, scan_installed_adapters
 from .project_paths import ProjectPaths, detect_project_paths
 
 console = Console()
+_UV_VERSION_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]*$")
 
 
 # ── Entry point ───────────────────────────────────────────────────────────────
@@ -274,7 +275,88 @@ def _resolve_adapter_params(
         value = _resolve_parameter(parameter, provided_values.get(parameter.name), project_dir, prompt_missing)
         resolved[parameter.name] = _render_parameter_value(parameter, value)
 
-    return resolved
+    return _normalize_adapter_params(adapter, resolved)
+
+
+def _normalize_adapter_params(adapter: AdapterSpec, params: dict[str, Any]) -> dict[str, Any]:
+    if adapter.capability == "http" and adapter.name == "cache-control":
+        return _normalize_cache_control_params(params)
+    if adapter.capability == "command-bus" and adapter.name == "rabbitmq":
+        return _normalize_rabbitmq_command_bus_params(params)
+    if adapter.capability == "runtime" and adapter.name == "docker-image":
+        return _normalize_docker_image_params(params)
+    return params
+
+
+def _normalize_cache_control_params(params: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(params)
+    for name in ("get_single_max_age", "get_list_max_age"):
+        raw_value = str(normalized[name]).strip()
+        try:
+            value = int(raw_value)
+        except ValueError:
+            console.print(
+                f"[red]✗[/red] Valeur entière invalide pour [bold]{name}[/bold]: {raw_value}."
+            )
+            raise typer.Exit(1) from None
+        if value < 0:
+            console.print(
+                f"[red]✗[/red] Valeur invalide pour [bold]{name}[/bold]: {value}. "
+                "Utilisez une valeur >= 0."
+            )
+            raise typer.Exit(1)
+        normalized[name] = value
+    return normalized
+
+
+def _normalize_rabbitmq_command_bus_params(params: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(params)
+    for name in ("prefetch", "concurrency"):
+        raw_value = str(normalized[name]).strip()
+        try:
+            value = int(raw_value)
+        except ValueError:
+            console.print(
+                f"[red]✗[/red] Valeur entière invalide pour [bold]{name}[/bold]: {raw_value}."
+            )
+            raise typer.Exit(1) from None
+        if value <= 0:
+            console.print(
+                f"[red]✗[/red] Valeur invalide pour [bold]{name}[/bold]: {value}. "
+                "Utilisez une valeur > 0."
+            )
+            raise typer.Exit(1)
+        normalized[name] = value
+    return normalized
+
+
+def _normalize_docker_image_params(params: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(params)
+    uv_version = str(normalized["uv_version"]).strip()
+    if not _UV_VERSION_RE.fullmatch(uv_version):
+        console.print(
+            "[red]✗[/red] Version uv invalide: utilisez un token sans espace, accolade ou saut de ligne."
+        )
+        raise typer.Exit(1)
+    normalized["uv_version"] = uv_version
+
+    for name in ("api_port", "mcp_port", "probe_port", "agent_port"):
+        raw_value = str(normalized[name]).strip()
+        try:
+            value = int(raw_value)
+        except ValueError:
+            console.print(
+                f"[red]✗[/red] Port entier invalide pour [bold]{name}[/bold]: {raw_value}."
+            )
+            raise typer.Exit(1) from None
+        if value <= 0 or value > 65535:
+            console.print(
+                f"[red]✗[/red] Port invalide pour [bold]{name}[/bold]: {value}. "
+                "Utilisez une valeur entre 1 et 65535."
+            )
+            raise typer.Exit(1)
+        normalized[name] = value
+    return normalized
 
 
 def _assert_supported_params(adapter: AdapterSpec, extra_params: dict[str, str]) -> None:
@@ -318,8 +400,38 @@ def _resolve_parameter(
     resolved = provided_value.strip() if isinstance(provided_value, str) else ""
     string_default = _default_string_value(parameter, project_dir)
     if not resolved and prompt_missing:
-        resolved = Prompt.ask(f"  {parameter.prompt}", default=string_default, password=parameter.secret).strip()
-    return resolved or string_default
+        prompt_kwargs: dict[str, Any] = {"password": parameter.secret}
+        if string_default:
+            prompt_kwargs["default"] = string_default
+        resolved = Prompt.ask(f"  {parameter.prompt}", **prompt_kwargs).strip()
+    resolved = resolved or string_default
+    if parameter.required and not resolved:
+        console.print(f"[red]✗[/red] Paramètre requis manquant: [bold]{parameter.name}[/bold].")
+        raise typer.Exit(1)
+    _assert_allowed_parameter_value(parameter, resolved)
+    return resolved
+
+
+def _assert_allowed_parameter_value(parameter: ParameterSpec, value: str) -> None:
+    if not parameter.choices:
+        return
+
+    values = _split_csv_values(value) if parameter.csv_choices else [value.strip()]
+    unknown = [item for item in values if item not in parameter.choices]
+    if not unknown:
+        return
+
+    allowed = ", ".join(parameter.choices)
+    received = ", ".join(unknown)
+    console.print(
+        f"[red]✗[/red] Valeur invalide pour [bold]{parameter.name}[/bold]: {received}. "
+        f"Valeurs: {allowed}."
+    )
+    raise typer.Exit(1)
+
+
+def _split_csv_values(value: str) -> list[str]:
+    return [item.strip() for item in value.split(",") if item.strip()]
 
 
 def _default_string_value(parameter: ParameterSpec, project_dir: Path) -> str:
@@ -405,16 +517,24 @@ def _list_generated_files(
         cfg = project_dir / adapter.config_path
         files.append((cfg, "remplacé ⚠" if cfg.exists() else "créé"))
 
+    for merge_template in adapter.merge_config_templates:
+        cfg = project_dir / render(merge_template.path, {})
+        files.append((cfg, "mis à jour" if cfg.exists() else "créé"))
+
     if adapter.has_env() and adapter.env_path:
         env_file = project_dir / adapter.env_path
         files.append((env_file, "mis à jour" if env_file.exists() else "créé"))
         gitignore = project_dir / ".gitignore"
         files.append((gitignore, "mis à jour" if gitignore.exists() else "créé"))
 
-    if adapter.has_secret_mappings():
+    if adapter.has_secret_mappings() or adapter.has_secret_config():
         secrets_file = project_dir / "config" / "secrets.yaml"
         files.append((secrets_file, "mis à jour" if secrets_file.exists() else "créé"))
 
+    if adapter.gitignore_entries:
+        gitignore = project_dir / ".gitignore"
+        files.append((gitignore, "mis à jour" if gitignore.exists() else "créé"))
+
     template_vars = _file_template_vars(project_dir, paths, adapter, params={})
     for file_template in adapter.file_templates:
         path = project_dir / render(file_template.path, template_vars)
@@ -465,21 +585,38 @@ def _generate(
         cfg_path.write_text(render(adapter.config_template, params), encoding="utf-8")
         console.print(f"[green]✓[/green] {cfg_path.relative_to(project_dir)}")
 
+    for merge_template in adapter.merge_config_templates:
+        cfg_path = project_dir / render(merge_template.path, params)
+        _merge_yaml_file(cfg_path, render(merge_template.template, params))
+        console.print(f"[green]✓[/green] {cfg_path.relative_to(project_dir)}")
+
     if adapter.has_env() and adapter.env_path:
         env_path = project_dir / adapter.env_path
         _merge_env_file(env_path, _parse_env_template(render(adapter.env_template, params)))
-        _ensure_env_is_ignored(project_dir)
+        _ensure_gitignore_entries(project_dir, (".env",))
         console.print(f"[green]✓[/green] {env_path.relative_to(project_dir)}")
 
-    if adapter.has_secret_mappings():
+    if adapter.has_secret_mappings() or adapter.has_secret_config():
         secrets_path = project_dir / "config" / "secrets.yaml"
-        _merge_secrets_file(secrets_path, adapter.secret_mappings)
+        _merge_secrets_file(
+            secrets_path,
+            adapter.secret_mappings,
+            resolver=adapter.secret_resolver,
+            config_template=adapter.secret_config_template,
+            params=params,
+        )
         console.print(f"[green]✓[/green] {secrets_path.relative_to(project_dir)}")
 
+    if adapter.gitignore_entries:
+        _ensure_gitignore_entries(project_dir, adapter.gitignore_entries)
+        console.print("[green]✓[/green] .gitignore")
+
     for file_template in adapter.file_templates:
         generated_path = project_dir / render(file_template.path, params)
         generated_path.parent.mkdir(parents=True, exist_ok=True)
         generated_path.write_text(render(file_template.template, params), encoding="utf-8")
+        if generated_path.name == "arclith-run":
+            generated_path.chmod(0o755)
         console.print(f"[green]✓[/green] {generated_path.relative_to(project_dir)}")
 
     import_vars = _import_vars(paths)
@@ -549,9 +686,38 @@ def _file_template_vars(
         "package_path": package_path,
         "langgraph_entrypoint": langgraph_entrypoint,
         "graph_name": graph_name,
+        "stream_mode_yaml": _langgraph_stream_mode_yaml(str(params.get("stream_mode") or "updates")),
+        "secret_template_yaml": _secret_template_yaml(str(params.get("field_path") or "")),
+        "secret_chain_yaml": _secret_chain_yaml(str(params.get("resolvers") or "")),
     }
 
 
+def _langgraph_stream_mode_yaml(stream_mode: str) -> str:
+    values = _split_csv_values(stream_mode)
+    if len(values) == 1:
+        return f'"{values[0]}"'
+    return yaml.safe_dump(values, default_flow_style=True, sort_keys=False).strip()
+
+
+def _secret_template_yaml(field_path: str) -> str:
+    keys = [key for key in field_path.split(".") if key]
+    if not keys:
+        return "# Ajouter les secrets locaux ici."
+
+    data: dict[str, Any] = {}
+    current = data
+    for key in keys[:-1]:
+        current[key] = {}
+        current = current[key]
+    current[keys[-1]] = "replace-me"
+    return yaml.safe_dump(data, sort_keys=False, allow_unicode=True).rstrip("\n")
+
+
+def _secret_chain_yaml(resolvers: str) -> str:
+    values = _split_csv_values(resolvers or "env,vault,yaml")
+    return "".join(f"  - {value}\n" for value in values).rstrip("\n")
+
+
 def _update_active_capability(project_dir: Path, capability: CapabilitySpec, adapter: AdapterSpec) -> None:
     if capability.activation_config_key is None:
         return
@@ -639,26 +805,71 @@ def _merge_env_file(env_path: Path, updates: dict[str, str]) -> None:
     env_path.write_text("\n".join(merged_lines).rstrip("\n") + "\n", encoding="utf-8")
 
 
-def _merge_secrets_file(secrets_path: Path, mappings: tuple[SecretMappingSpec, ...]) -> None:
+def _merge_yaml_file(path: Path, rendered_yaml: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = _read_yaml_mapping(path)
+    update = yaml.safe_load(rendered_yaml) or {}
+    if not isinstance(update, dict):
+        console.print("[red]✗[/red] La configuration YAML générée doit être un mapping.")
+        raise typer.Exit(1)
+    merged = _deep_merge_mapping(existing, update)
+    path.write_text(yaml.safe_dump(merged, sort_keys=False, allow_unicode=True), encoding="utf-8")
+
+
+def _merge_secrets_file(
+    secrets_path: Path,
+    mappings: tuple[SecretMappingSpec, ...],
+    *,
+    resolver: str | None = None,
+    config_template: str = "",
+    params: dict[str, Any] | None = None,
+) -> None:
     secrets_path.parent.mkdir(parents=True, exist_ok=True)
     data = _read_yaml_mapping(secrets_path)
-    resolver = data.get("resolver")
-    if not isinstance(resolver, str) or not resolver.strip():
+    existing_resolver = data.get("resolver")
+    if resolver is not None:
+        data["resolver"] = resolver
+    elif not isinstance(existing_resolver, str) or not existing_resolver.strip():
         data["resolver"] = "env"
 
+    render_params = params or {}
+    if config_template:
+        rendered_config = render(config_template, render_params)
+        config_data = yaml.safe_load(rendered_config) or {}
+        if not isinstance(config_data, dict):
+            console.print("[red]✗[/red] La configuration de secrets générée doit être un mapping YAML.")
+            raise typer.Exit(1)
+        data = _deep_merge_mapping(data, config_data)
+
     existing_mappings = data.get("mappings")
     if not isinstance(existing_mappings, dict):
         existing_mappings = {}
 
     merged_mappings = dict(existing_mappings)
     for mapping in mappings:
-        merged_mappings[mapping.field_path] = mapping.secret_key
+        field_path = render(mapping.field_path, render_params).strip()
+        secret_key = render(mapping.secret_key, render_params).strip()
+        if not field_path:
+            console.print("[red]✗[/red] Un mapping de secret doit cibler un champ non vide.")
+            raise typer.Exit(1)
+        merged_mappings[field_path] = secret_key
     data["mappings"] = merged_mappings
 
     rendered = yaml.safe_dump(data, sort_keys=False, allow_unicode=True)
     secrets_path.write_text(rendered, encoding="utf-8")
 
 
+def _deep_merge_mapping(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = dict(base)
+    for key, value in override.items():
+        current = result.get(key)
+        if isinstance(current, dict) and isinstance(value, dict):
+            result[key] = _deep_merge_mapping(current, value)
+        else:
+            result[key] = value
+    return result
+
+
 def _read_yaml_mapping(path: Path) -> dict[str, Any]:
     if not path.exists():
         return {}
@@ -669,15 +880,17 @@ def _read_yaml_mapping(path: Path) -> dict[str, Any]:
     return {}
 
 
-def _ensure_env_is_ignored(project_dir: Path) -> None:
+def _ensure_gitignore_entries(project_dir: Path, entries: tuple[str, ...]) -> None:
     gitignore = project_dir / ".gitignore"
     if gitignore.exists():
         lines = gitignore.read_text(encoding="utf-8").splitlines()
     else:
         lines = []
-    if ".env" in {line.strip() for line in lines}:
+    existing = {line.strip() for line in lines}
+    missing = [entry for entry in entries if entry not in existing]
+    if not missing:
         return
     if lines and lines[-1].strip():
         lines.append("")
-    lines.append(".env")
+    lines.extend(missing)
     gitignore.write_text("\n".join(lines).rstrip("\n") + "\n", encoding="utf-8")