arclith-cli 0.9.0__tar.gz → 0.11.0__tar.gz

{arclith_cli-0.9.0 → arclith_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arclith-cli
-Version: 0.9.0
+Version: 0.11.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.12.0
+Requires-Dist: arclith>=0.14.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{arclith_cli-0.9.0 → arclith_cli-0.11.0}/README.md

@@ -10,6 +10,25 @@ uv tool install "git+https://github.com/karned-rekipe/arclith.git#subdirectory=c
 
 ## Commandes
 
+### `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.
+
+```bash
+# Mode interactif
+arclith-cli init
+
+# Mode direct
+arclith-cli init todo-list-service
+arclith-cli init todo-list-service --dir ~/projects
+```
+
+Cette commande ne crée aucune entité, aucun CRUD et aucun endpoint métier. Elle sert quand on veut
+construire le projet étape par étape avec `add-entity`, `add-usecase`, puis `add-adapter`.
+
+---
+
 ### `new` — Créer un projet
 
 Scaffold un nouveau projet arclith depuis le template officiel `_sample`.
@@ -34,6 +53,71 @@ Le projet généré utilise un layout `src/<package>/...` pour le code applicati
 
 ---
 
+### `add-entity` — Ajouter une entité métier
+
+Crée uniquement le fichier minimal d'une entité dans `src/<package>/domain/models/`.
+
+```bash
+cd my-recipe-service
+arclith-cli add-entity ShoppingItem
+```
+
+Fichier généré :
+
+```text
+src/<package>/domain/models/shopping_item.py
+```
+
+La commande ne génère aucun CRUD, aucun port repository, aucun adapter et aucun endpoint. Elle pose seulement le point d'ancrage du modèle métier ; le développeur complète ensuite les champs et invariants de l'entité.
+
+---
+
+### `add-usecase` — Ajouter un cas d'usage
+
+Crée le port inbound minimal dans `src/<package>/domain/ports/inbound/`, puis le fichier minimal du
+cas d'usage dans `src/<package>/application/use_cases/`.
+
+```bash
+cd my-recipe-service
+arclith-cli add-usecase PlanShoppingList
+arclith-cli add-usecase find-by-name
+```
+
+Fichier généré :
+
+```text
+src/<package>/domain/ports/inbound/plan_shopping_list.py
+src/<package>/application/use_cases/plan_shopping_list.py
+```
+
+Le nom peut être fourni en PascalCase, snake_case ou kebab-case. Le suffixe `UseCase` est normalisé : `PlanShoppingListUseCase` et `plan-shopping-list-use-case` génèrent tous les deux `PlanShoppingListUseCase`.
+
+Comme `add-entity`, cette commande ne câble pas FastAPI, FastMCP, LangGraph, un repository ou un service. Les adapters se branchent ensuite explicitement avec `add-adapter` et devraient dépendre du port inbound généré.
+
+---
+
+### `add-planner` — Ajouter un planner applicatif
+
+Crée uniquement le fichier minimal d'un planner dans `src/<package>/application/planners/`.
+
+```bash
+cd my-recipe-service
+arclith-cli add-planner IngredientIntent
+arclith-cli add-planner command-router
+```
+
+Fichier généré :
+
+```text
+src/<package>/application/planners/ingredient_intent.py
+```
+
+Le planner est le composant applicatif qui transforme une demande naturelle en commande ou DTO
+structuré. Il ne remplace pas LangGraph : LangGraph orchestre les nœuds, tandis que le planner porte
+la traduction d'intention. Le fichier généré reste volontairement vide de logique métier.
+
+---
+
 ### `add-adapter` — Ajouter un adapter
 
 Wizard interactif à lancer **depuis la racine du projet cible**. Scaffold le code Python et/ou les fichiers de configuration pour un nouvel adapter. Par défaut, la capacité cible est `repository`.
@@ -49,29 +133,39 @@ Mode direct, utile pour CI, scripts de migration ou commandes reproductibles :
 arclith-cli add-adapter --adapter mongodb --entity Recipe --db-name my_recipe_service --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 observability --adapter langsmith
+arclith-cli add-adapter --capability observability --adapter opentelemetry --param service_name=my_recipe_service --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` · `langgraph` · `langsmith`
-2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour `agent/langgraph` et `observability/langsmith`
+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
 3. **Paramètres** — questions spécifiques à l'adapter :
    - `mongodb` → `db_name`, `multitenant`
    - `duckdb` → `path`
    - `mariadb` → `host`, `port`, `database`, `user`, `driver`, `table_prefix`
+   - `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`
    - `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 à sélecteur (`repository: <adapter>` ou `observability: langsmith`) ; `agent/langgraph` est exposé par `langgraph.json` et `config/adapters/inbound/langgraph.yaml`
+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
 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`, `agent`, `observability`) |
-| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `langgraph`, `langsmith` |
+| `--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` |
 | `--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 |
@@ -97,20 +191,38 @@ src/<package>/infrastructure/containers/<entity>_container.py  # RepositoryRegis
 
 ```bash
 uv add "arclith[langgraph]"
+arclith-cli add-adapter --capability llm --adapter lmstudio --param model_name=qwen/qwen3.5-9b --yes
 arclith-cli add-adapter --capability agent --adapter langgraph
 arclith-cli add-adapter --capability observability --adapter langsmith
 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`.
+
 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
-`config/adapters/outbound/langsmith.yaml`, met
+`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
 n'est fournie.
 
+**OpenTelemetry :**
+
+```bash
+uv add "arclith[opentelemetry]"
+arclith-cli add-adapter --capability observability --adapter opentelemetry --param service_name=my-recipe-service --yes
+```
+
+L'adapter `observability/opentelemetry` génère `config/adapters/outbound/opentelemetry.yaml`, met à
+jour `.env`, l'ajoute à `observability.enabled` et branche l'instrumentation FastAPI quand
+`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`.
+
 Parcours complet avec entité, API, LangGraph, LangSmith et LM Studio:
 [`docs/agent-quickstart.md`](../docs/agent-quickstart.md).
 
@@ -178,12 +290,14 @@ config/
   soft_delete.yaml                # soft_delete: { retention_days }
   secrets.yaml                    # secrets: { resolver, mappings, vault, yaml }
   adapters/
-    adapters.yaml                 # adapters: { logger, repository }   ← adapter actif
+    adapters.yaml                 # adapters: { logger, repository, observability.enabled }
     outbound/
       mongodb.yaml                # adapters.mongodb: { db_name, multitenant }
       duckdb.yaml                 # adapters.duckdb: { path, multitenant }
       mariadb.yaml                # adapters.mariadb: { host, port, database, user, ... }
+      lm.yaml                     # adapters.lm: { provider, model_name, api_key, base_url }
       langsmith.yaml              # adapters.langsmith: { tracing, project, endpoint, ... }
+      opentelemetry.yaml          # adapters.opentelemetry: { endpoint, protocol, traces, metrics, ... }
     inbound/
       fastapi.yaml                # api: { host, port, reload }
       fastmcp.yaml                # mcp: { host, port }
@@ -199,7 +313,10 @@ Pour changer l'adapter actif sans passer par le wizard :
 ```yaml
 # config/adapters/adapters.yaml
 repository: duckdb   # memory | mongodb | duckdb | mariadb
-observability: langsmith
+observability:
+  enabled:
+    - langsmith
+    - 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.

arclith_cli-0.11.0/arclith_cli/__init__.py

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

{arclith_cli-0.9.0 → arclith_cli-0.11.0}/arclith_cli/add_adapter.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any
 
 import typer
+import yaml
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
@@ -20,6 +21,7 @@ from .capabilities import (
     AdapterSpec,
     CapabilitySpec,
     ParameterSpec,
+    SecretMappingSpec,
     capability_names,
     get_capability,
 )
@@ -384,7 +386,7 @@ def _show_recap(
         cfg_path = project_dir / "config" / "adapters" / "adapters.yaml"
         table.add_row(
             str(cfg_path.relative_to(project_dir)),
-            f"[cyan]mis à jour ({capability.activation_config_key})[/cyan]",
+            f"[cyan]mis à jour ({_activation_config_label(capability)})[/cyan]",
         )
 
     console.print()
@@ -409,6 +411,10 @@ def _list_generated_files(
         gitignore = project_dir / ".gitignore"
         files.append((gitignore, "mis à jour" if gitignore.exists() else "créé"))
 
+    if adapter.has_secret_mappings():
+        secrets_file = project_dir / "config" / "secrets.yaml"
+        files.append((secrets_file, "mis à jour" if secrets_file.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)
@@ -430,6 +436,12 @@ def _list_generated_files(
     return files
 
 
+def _activation_config_label(capability: CapabilitySpec) -> str:
+    if capability.name == "observability":
+        return "observability.enabled"
+    return capability.activation_config_key or ""
+
+
 # ── Step 5 : generate ─────────────────────────────────────────────────────────
 
 def _generate(
@@ -459,6 +471,11 @@ def _generate(
         _ensure_env_is_ignored(project_dir)
         console.print(f"[green]✓[/green] {env_path.relative_to(project_dir)}")
 
+    if adapter.has_secret_mappings():
+        secrets_path = project_dir / "config" / "secrets.yaml"
+        _merge_secrets_file(secrets_path, adapter.secret_mappings)
+        console.print(f"[green]✓[/green] {secrets_path.relative_to(project_dir)}")
+
     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)
@@ -538,6 +555,10 @@ def _file_template_vars(
 def _update_active_capability(project_dir: Path, capability: CapabilitySpec, adapter: AdapterSpec) -> None:
     if capability.activation_config_key is None:
         return
+    if capability.name == "observability":
+        _enable_observability_adapter(project_dir, adapter)
+        return
+
     cfg = project_dir / "config" / "adapters" / "adapters.yaml"
     key = capability.activation_config_key
     escaped_key = re.escape(key)
@@ -554,6 +575,29 @@ def _update_active_capability(project_dir: Path, capability: CapabilitySpec, ada
     console.print(f"[cyan]↺[/cyan] config/adapters/adapters.yaml → {key}: {adapter.name}")
 
 
+def _enable_observability_adapter(project_dir: Path, adapter: AdapterSpec) -> None:
+    cfg = project_dir / "config" / "adapters" / "adapters.yaml"
+    data = _read_yaml_mapping(cfg)
+    existing = data.get("observability")
+    if isinstance(existing, dict) and isinstance(existing.get("enabled"), list):
+        enabled = []
+        for name in existing["enabled"]:
+            if isinstance(name, str) and name not in enabled:
+                enabled.append(name)
+    else:
+        enabled = []
+
+    if adapter.name not in enabled:
+        enabled.append(adapter.name)
+
+    data["observability"] = {"enabled": enabled}
+    cfg.parent.mkdir(parents=True, exist_ok=True)
+    cfg.write_text(yaml.safe_dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
+    console.print(
+        f"[cyan]↺[/cyan] config/adapters/adapters.yaml → observability.enabled += {adapter.name}"
+    )
+
+
 def _parse_env_template(rendered: str) -> dict[str, str]:
     values: dict[str, str] = {}
     for line in rendered.splitlines():
@@ -595,6 +639,36 @@ 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:
+    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():
+        data["resolver"] = "env"
+
+    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
+    data["mappings"] = merged_mappings
+
+    rendered = yaml.safe_dump(data, sort_keys=False, allow_unicode=True)
+    secrets_path.write_text(rendered, encoding="utf-8")
+
+
+def _read_yaml_mapping(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    loaded = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    if isinstance(loaded, dict):
+        return dict(loaded)
+    return {}
+
+
 def _ensure_env_is_ignored(project_dir: Path) -> None:
     gitignore = project_dir / ".gitignore"
     if gitignore.exists():