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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arclith-cli
-Version: 0.9.0
+Version: 0.10.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.13.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.10.0}/README.md

@@ -34,6 +34,47 @@ 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 uniquement le fichier minimal d'un 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>/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`.
+
+---
+
 ### `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 +90,35 @@ 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 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` · `langgraph` · `langsmith` · `opentelemetry`
+2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour les transports globaux, `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`
    - `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 à sélecteur (`repository: <adapter>` ou `observability: <adapter>`) ; `api/fastapi`, `mcp/fastmcp` et `agent/langgraph` sont exposés par leurs fichiers `config/adapters/inbound/*.yaml`
 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`, `agent`, `observability`) |
+| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `fastapi`, `fastmcp`, `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 |
@@ -111,6 +158,17 @@ son agent. Comme `fastapi` et `fastmcp`, LangGraph est configuré par son nom pr
 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`, active `observability: opentelemetry` et branche l'instrumentation FastAPI quand
+`Arclith.fastapi()` construit l'application.
+
 Parcours complet avec entité, API, LangGraph, LangSmith et LM Studio:
 [`docs/agent-quickstart.md`](../docs/agent-quickstart.md).
 
@@ -184,6 +242,7 @@ config/
       duckdb.yaml                 # adapters.duckdb: { path, multitenant }
       mariadb.yaml                # adapters.mariadb: { host, port, database, user, ... }
       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 +258,7 @@ Pour changer l'adapter actif sans passer par le wizard :
 ```yaml
 # config/adapters/adapters.yaml
 repository: duckdb   # memory | mongodb | duckdb | mariadb
-observability: langsmith
+observability: langsmith   # none | 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.10.0/arclith_cli/__init__.py

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

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/arclith_cli/capabilities.py

@@ -217,6 +217,83 @@ multitenant: false
     ),
 )
 
+API_CAPABILITY = CapabilitySpec(
+    name="api",
+    layer="inbound",
+    description="Transport HTTP REST expose via FastAPI.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="fastapi",
+            capability="api",
+            layer="inbound",
+            description="Application FastAPI configuree par Arclith.fastapi().",
+            config_path="config/adapters/inbound/fastapi.yaml",
+            config_template="""\
+host: {host}
+port: {port}
+reload: {reload}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="host",
+                    kind="string",
+                    prompt="Host FastAPI",
+                    default="0.0.0.0",
+                ),
+                ParameterSpec(
+                    name="port",
+                    kind="string",
+                    prompt="Port FastAPI",
+                    default="8000",
+                ),
+                ParameterSpec(
+                    name="reload",
+                    kind="boolean",
+                    prompt="Activer le reload FastAPI",
+                    default=True,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+    ),
+)
+
+MCP_CAPABILITY = CapabilitySpec(
+    name="mcp",
+    layer="inbound",
+    description="Transport MCP expose via FastMCP.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="fastmcp",
+            capability="mcp",
+            layer="inbound",
+            description="Serveur FastMCP configure par Arclith.fastmcp() et les runners MCP.",
+            config_path="config/adapters/inbound/fastmcp.yaml",
+            config_template="""\
+host: {host}
+port: {port}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="host",
+                    kind="string",
+                    prompt="Host FastMCP",
+                    default="127.0.0.1",
+                ),
+                ParameterSpec(
+                    name="port",
+                    kind="string",
+                    prompt="Port FastMCP",
+                    default="8001",
+                ),
+            ),
+            entity_scoped=False,
+        ),
+    ),
+)
+
 AGENT_CAPABILITY = CapabilitySpec(
     name="agent",
     layer="inbound",
@@ -351,10 +428,99 @@ LANGSMITH_API_KEY={api_key}
             ),
             entity_scoped=False,
         ),
+        AdapterSpec(
+            name="opentelemetry",
+            capability="observability",
+            layer="outbound",
+            description="Export OTLP traces/metrics et instrumentation FastAPI.",
+            config_path="config/adapters/outbound/opentelemetry.yaml",
+            config_template="""\
+enabled: {enabled}
+service_name: "{service_name}"
+endpoint: "{endpoint}"
+protocol: "{protocol}"
+headers_env: OTEL_EXPORTER_OTLP_HEADERS
+traces: {traces}
+metrics: {metrics}
+instrument_fastapi: {instrument_fastapi}
+metrics_export_interval_millis: {metrics_export_interval_millis}
+""",
+            env_path=".env",
+            env_template="""\
+OTEL_SERVICE_NAME={service_name}
+OTEL_EXPORTER_OTLP_ENDPOINT={endpoint}
+OTEL_EXPORTER_OTLP_PROTOCOL={protocol}
+OTEL_EXPORTER_OTLP_HEADERS={headers}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="enabled",
+                    kind="boolean",
+                    prompt="Activer OpenTelemetry",
+                    default=True,
+                ),
+                ParameterSpec(
+                    name="service_name",
+                    kind="string",
+                    prompt="OTEL_SERVICE_NAME",
+                    default_from_project_name=True,
+                ),
+                ParameterSpec(
+                    name="endpoint",
+                    kind="string",
+                    prompt="OTLP endpoint",
+                    default="http://localhost:4318",
+                ),
+                ParameterSpec(
+                    name="protocol",
+                    kind="string",
+                    prompt="OTLP protocol",
+                    default="http/protobuf",
+                ),
+                ParameterSpec(
+                    name="traces",
+                    kind="boolean",
+                    prompt="Exporter les traces",
+                    default=True,
+                ),
+                ParameterSpec(
+                    name="metrics",
+                    kind="boolean",
+                    prompt="Exporter les metriques",
+                    default=False,
+                ),
+                ParameterSpec(
+                    name="instrument_fastapi",
+                    kind="boolean",
+                    prompt="Instrumenter FastAPI",
+                    default=True,
+                ),
+                ParameterSpec(
+                    name="metrics_export_interval_millis",
+                    kind="string",
+                    prompt="Intervalle export metriques en ms",
+                    default="60000",
+                ),
+                ParameterSpec(
+                    name="headers",
+                    kind="string",
+                    prompt="OTEL_EXPORTER_OTLP_HEADERS",
+                    default="",
+                    secret=True,
+                ),
+            ),
+            entity_scoped=False,
+        ),
     ),
 )
 
-CAPABILITY_CATALOG = (REPOSITORY_CAPABILITY, AGENT_CAPABILITY, OBSERVABILITY_CAPABILITY)
+CAPABILITY_CATALOG = (
+    REPOSITORY_CAPABILITY,
+    API_CAPABILITY,
+    MCP_CAPABILITY,
+    AGENT_CAPABILITY,
+    OBSERVABILITY_CAPABILITY,
+)
 
 
 def get_capability(name: str) -> CapabilitySpec | None:

arclith_cli-0.10.0/arclith_cli/core_scaffold.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from .project_paths import ProjectPaths, detect_project_paths
+from .rename import EntityNames
+
+console = Console()
+
+_NAME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_\-]*$")
+
+_ENTITY_TEMPLATE = """from arclith.domain.models.entity import Entity
+
+
+class {class_name}(Entity):
+    pass
+"""
+
+_USE_CASE_TEMPLATE = """class {class_name}UseCase:
+    async def execute(self) -> None:
+        raise NotImplementedError("Implement {class_name}UseCase.execute")
+"""
+
+
+@dataclass(frozen=True)
+class UseCaseNames:
+    pascal: str
+    snake: str
+
+    @classmethod
+    def from_input(cls, raw: str) -> UseCaseNames:
+        names = EntityNames.from_input(raw)
+        pascal = _strip_pascal_suffix(names.pascal)
+        snake = _strip_snake_suffix(names.snake)
+        if not pascal or not snake:
+            console.print(f"[red]✗[/red] Nom de cas d'usage invalide : [bold]{raw}[/bold].")
+            raise typer.Exit(1)
+        return cls(pascal=pascal, snake=snake)
+
+
+def add_entity_cmd(*, project_dir: Path | None = None, entity_name: str) -> Path:
+    project_dir = project_dir or Path.cwd()
+    entity_name = entity_name.strip()
+    _assert_project_root(project_dir, command="add-entity")
+    _assert_valid_name(entity_name, label="entité")
+
+    paths = detect_project_paths(project_dir)
+    names = EntityNames.from_input(entity_name)
+    entity_file = paths.domain_models / f"{names.snake}.py"
+    _assert_missing(entity_file, project_dir)
+
+    _ensure_package_dirs(paths, "domain", "models")
+    entity_file.write_text(_ENTITY_TEMPLATE.format(class_name=names.pascal), encoding="utf-8")
+    console.print(
+        f"[green]✓[/green] Entité {names.pascal} créée : "
+        f"[bold]{entity_file.relative_to(project_dir)}[/bold]"
+    )
+    return entity_file
+
+
+def add_usecase_cmd(*, project_dir: Path | None = None, usecase_name: str) -> Path:
+    project_dir = project_dir or Path.cwd()
+    usecase_name = usecase_name.strip()
+    _assert_project_root(project_dir, command="add-usecase")
+    _assert_valid_name(usecase_name, label="cas d'usage")
+
+    paths = detect_project_paths(project_dir)
+    names = UseCaseNames.from_input(usecase_name)
+    usecase_file = paths.application_use_cases / f"{names.snake}.py"
+    _assert_missing(usecase_file, project_dir)
+
+    _ensure_package_dirs(paths, "application", "use_cases")
+    usecase_file.write_text(_USE_CASE_TEMPLATE.format(class_name=names.pascal), encoding="utf-8")
+    console.print(
+        f"[green]✓[/green] Cas d'usage {names.pascal}UseCase créé : "
+        f"[bold]{usecase_file.relative_to(project_dir)}[/bold]"
+    )
+    return usecase_file
+
+
+def _assert_project_root(project_dir: Path, *, command: str) -> None:
+    if not project_dir.exists() or not project_dir.is_dir():
+        console.print(f"[red]✗[/red] Répertoire introuvable : [bold]{project_dir}[/bold].")
+        raise typer.Exit(1)
+
+    has_project_marker = (
+        (project_dir / "pyproject.toml").exists()
+        or (project_dir / "src").is_dir()
+        or (project_dir / "config").is_dir()
+    )
+    if has_project_marker:
+        return
+
+    console.print(
+        f"[red]✗[/red] Aucun projet arclith détecté.\n"
+        f"    Exécutez [bold]arclith-cli {command}[/bold] depuis la racine du projet."
+    )
+    raise typer.Exit(1)
+
+
+def _assert_valid_name(raw: str, *, label: str) -> None:
+    if _NAME_RE.match(raw.strip()):
+        return
+
+    console.print(
+        f"[red]✗[/red] Nom de {label} invalide : [bold]{raw}[/bold]. "
+        "Lettres, chiffres, _ et - uniquement. Doit commencer par une lettre."
+    )
+    raise typer.Exit(1)
+
+
+def _assert_missing(path: Path, project_dir: Path) -> None:
+    if not path.exists():
+        return
+
+    console.print(f"[red]✗[/red] Le fichier existe déjà : [bold]{path.relative_to(project_dir)}[/bold].")
+    raise typer.Exit(1)
+
+
+def _ensure_package_dirs(paths: ProjectPaths, *relative_parts: str) -> None:
+    target_dir = paths.package_root.joinpath(*relative_parts)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    stop_at = paths.package_root.parent if paths.package_name is not None else paths.package_root
+    init_dirs = [target_dir]
+    for parent in target_dir.parents:
+        if parent == stop_at:
+            break
+        init_dirs.append(parent)
+
+    for directory in init_dirs:
+        init_file = directory / "__init__.py"
+        if not init_file.exists():
+            init_file.write_text("", encoding="utf-8")
+
+
+def _strip_pascal_suffix(value: str) -> str:
+    suffixes = ("UseCase", "Usecase")
+    while True:
+        stripped = value
+        for suffix in suffixes:
+            if stripped.endswith(suffix):
+                stripped = stripped[: -len(suffix)]
+                break
+        if stripped == value:
+            return value
+        value = stripped
+
+
+def _strip_snake_suffix(value: str) -> str:
+    suffixes = ("_use_case", "_usecase")
+    while True:
+        stripped = value
+        for suffix in suffixes:
+            if stripped.endswith(suffix):
+                stripped = stripped[: -len(suffix)]
+                break
+        if stripped == value:
+            return value
+        value = stripped

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/arclith_cli/main.py

@@ -15,6 +15,7 @@ from rich.tree import Tree
 from . import __version__
 from .add_adapter import add_adapter_cmd
 from .capabilities import CAPABILITY_CATALOG, capability_catalog_as_dict
+from .core_scaffold import add_entity_cmd, add_usecase_cmd
 from .export_config import export_config_cmd
 from .rename import EntityNames, apply_rename
 from .scaffold import download_and_extract
@@ -121,7 +122,7 @@ def version() -> None:
 def add_adapter(
     capability: Annotated[
         str,
-        typer.Option("--capability", help="Capacité cible: repository, agent ou observability"),
+        typer.Option("--capability", help="Capacité cible: repository, api, mcp, agent ou observability"),
     ] = "repository",
     adapter: Annotated[
         str | None,
@@ -178,6 +179,32 @@ def add_adapter(
     )
 
 
+@app.command(name="add-entity")
+def add_entity(
+    entity: Annotated[
+        str | None,
+        typer.Argument(
+            help="Nom de l'entité métier au singulier. Exemple : Recipe, recipe_step, meal-plan",
+        ),
+    ] = None,
+) -> None:
+    """Créer uniquement le fichier minimal d'une entité métier dans domain/models."""
+    add_entity_cmd(entity_name=entity or _prompt_entity())
+
+
+@app.command(name="add-usecase")
+def add_usecase(
+    usecase: Annotated[
+        str | None,
+        typer.Argument(
+            help="Nom du cas d'usage. Exemple : PlanShoppingList, find_by_name, import-catalog",
+        ),
+    ] = None,
+) -> None:
+    """Créer uniquement le fichier minimal d'un cas d'usage dans application/use_cases."""
+    add_usecase_cmd(usecase_name=usecase or _prompt_usecase())
+
+
 @app.command(name="capabilities")
 def capabilities(
     as_json: Annotated[
@@ -256,6 +283,21 @@ def _prompt_project() -> str:
             return value
 
 
+def _prompt_usecase() -> str:
+    console.print("\n[bold]Cas d'usage[/bold] [dim](ex : PlanShoppingList, find_by_name)[/dim]")
+    while True:
+        value = Prompt.ask("  [bold green]Nom du cas d'usage[/bold green]").strip()
+        if not value:
+            console.print("  [red]Le nom ne peut pas être vide.[/red]")
+        elif not _ENTITY_RE.match(value):
+            console.print(
+                "  [red]Caractères invalides.[/red] "
+                "[dim]Lettres, chiffres, _ et - uniquement. Doit commencer par une lettre.[/dim]"
+            )
+        else:
+            return value
+
+
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
 def _split_entity_option(value: str | None) -> list[str] | None:

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/arclith_cli/project_paths.py

@@ -12,6 +12,10 @@ class ProjectPaths:
     def domain_models(self) -> Path:
         return self.package_root / "domain" / "models"
 
+    @property
+    def application_use_cases(self) -> Path:
+        return self.package_root / "application" / "use_cases"
+
     @property
     def adapters_outbound(self) -> Path:
         return self.package_root / "adapters" / "outbound"
@@ -33,13 +37,29 @@ def detect_project_paths(project_dir: Path) -> ProjectPaths:
     """Detect the importable application package for an Arclith project."""
     src_dir = project_dir / "src"
     if src_dir.exists():
-        candidates = sorted(
+        model_candidates = sorted(
             child
             for child in src_dir.iterdir()
             if child.is_dir() and (child / "domain" / "models").exists()
         )
-        if candidates:
-            package_root = candidates[0]
+        if model_candidates:
+            package_root = model_candidates[0]
+            return ProjectPaths(root=project_dir, package_root=package_root, package_name=package_root.name)
+
+        package_candidates = sorted(
+            child
+            for child in src_dir.iterdir()
+            if child.is_dir() and _looks_like_package_root(child)
+        )
+        if package_candidates:
+            package_root = package_candidates[0]
             return ProjectPaths(root=project_dir, package_root=package_root, package_name=package_root.name)
 
     return ProjectPaths(root=project_dir, package_root=project_dir, package_name=None)
+
+
+def _looks_like_package_root(path: Path) -> bool:
+    if (path / "__init__.py").exists():
+        return True
+
+    return any((path / layer).is_dir() for layer in ("domain", "application", "adapters", "infrastructure"))

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/arclith_cli/rename.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
+from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 
 _SOURCE_PASCAL = "Ingredient"
@@ -89,9 +90,10 @@ def _patch_pyproject(target_dir: Path, project_name: str) -> None:
     p = target_dir / "pyproject.toml"
     if not p.exists():
         return
-    text = p.read_text()
+    text = p.read_text(encoding="utf-8")
     # Update project name (first occurrence)
     text = re.sub(r'(?m)^name\s*=\s*"[^"]*"', f'name = "{project_name}"', text, count=1)
+    text = _patch_arclith_dependency(text)
     # Remove [tool.uv.sources] block (editable arclith path)
     text = re.sub(
         r"\[tool\.uv\.sources\]\n(?:[^\[]*)",
@@ -99,7 +101,26 @@ def _patch_pyproject(target_dir: Path, project_name: str) -> None:
         text,
         flags=re.DOTALL,
     )
-    p.write_text(text.strip() + "\n")
+    p.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def _patch_arclith_dependency(text: str) -> str:
+    framework_version = _installed_arclith_version()
+    if framework_version is None:
+        return text
+    return re.sub(
+        r'("arclith(?:\[[^"]+\])?>=)[^"]+(")',
+        lambda match: f"{match.group(1)}{framework_version}{match.group(2)}",
+        text,
+        count=1,
+    )
+
+
+def _installed_arclith_version() -> str | None:
+    try:
+        return version("arclith")
+    except PackageNotFoundError:
+        return None
 
 
 # ── config/ directory patching ────────────────────────────────────────────────

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arclith-cli"
-version = "0.9.0"
+version = "0.10.0"
 description = "CLI scaffolding tool for arclith — hexagonal architecture framework"
 license = { file = "LICENSE" }
 requires-python = ">=3.13"
@@ -16,7 +16,7 @@ dependencies = [
     "typer>=0.15.0",
     "rich>=13.0.0",
     "httpx>=0.27.0",
-    "arclith>=0.12.0",
+    "arclith>=0.13.0",
 ]
 
 [tool.uv.sources]

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/e2e_manual.sh

@@ -39,7 +39,7 @@ if grep -q '\[tool\.uv\.sources\]' pyproject.toml; then
 fi
 
 ARCLITH_VERSION=$(grep 'arclith\[' pyproject.toml | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
-MIN_ARCLITH_VERSION="0.12.0"
+MIN_ARCLITH_VERSION="0.13.0"
 if version_lt "$ARCLITH_VERSION" "$MIN_ARCLITH_VERSION"; then
     echo -e "${RED}✗ FAIL: arclith version < $MIN_ARCLITH_VERSION (found: $ARCLITH_VERSION)${NC}"
     exit 1

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/test_add_adapter.py

@@ -194,6 +194,106 @@ def test_add_langsmith_skips_missing_empty_api_key(tmp_path: Path) -> None:
     assert "LANGSMITH_PROJECT=agent-tests" in env
 
 
+def test_add_fastapi_api_adapter_generates_inbound_config_only(tmp_path: Path) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    add_adapter_cmd(
+        project_dir=project_dir,
+        capability_name="api",
+        adapter="fastapi",
+        adapter_params={
+            "host": "127.0.0.1",
+            "port": "8080",
+            "reload": "false",
+        },
+        yes=True,
+    )
+
+    config = (project_dir / "config" / "adapters" / "inbound" / "fastapi.yaml").read_text(
+        encoding="utf-8"
+    )
+    assert "host: 127.0.0.1" in config
+    assert "port: 8080" in config
+    assert "reload: false" in config
+    assert "repository: memory" in (project_dir / "config" / "adapters" / "adapters.yaml").read_text(
+        encoding="utf-8"
+    )
+    package_root = project_dir / "src" / "demo_service"
+    assert not (package_root / "adapters" / "outbound" / "fastapi").exists()
+
+
+def test_add_fastmcp_mcp_adapter_generates_inbound_config_only(tmp_path: Path) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    add_adapter_cmd(
+        project_dir=project_dir,
+        capability_name="mcp",
+        adapter="fastmcp",
+        adapter_params={
+            "host": "127.0.0.1",
+            "port": "9001",
+        },
+        yes=True,
+    )
+
+    config = (project_dir / "config" / "adapters" / "inbound" / "fastmcp.yaml").read_text(
+        encoding="utf-8"
+    )
+    assert "host: 127.0.0.1" in config
+    assert "port: 9001" in config
+    assert "repository: memory" in (project_dir / "config" / "adapters" / "adapters.yaml").read_text(
+        encoding="utf-8"
+    )
+    package_root = project_dir / "src" / "demo_service"
+    assert not (package_root / "adapters" / "outbound" / "fastmcp").exists()
+
+
+def test_add_opentelemetry_observability_adapter_uses_catalog_params(tmp_path: Path) -> None:
+    project_dir = _minimal_project(tmp_path)
+    (project_dir / ".env").write_text("EXISTING=value\n", encoding="utf-8")
+
+    add_adapter_cmd(
+        project_dir=project_dir,
+        capability_name="observability",
+        adapter="opentelemetry",
+        adapter_params={
+            "service_name": "demo-api",
+            "endpoint": "http://otel-collector:4318",
+            "protocol": "http/protobuf",
+            "traces": "true",
+            "metrics": "true",
+            "instrument_fastapi": "true",
+            "metrics_export_interval_millis": "15000",
+            "headers": "authorization=Bearer test",
+        },
+        yes=True,
+    )
+
+    config = (project_dir / "config" / "adapters" / "outbound" / "opentelemetry.yaml").read_text(
+        encoding="utf-8"
+    )
+    assert "enabled: true" in config
+    assert 'service_name: "demo-api"' in config
+    assert 'endpoint: "http://otel-collector:4318"' in config
+    assert 'protocol: "http/protobuf"' in config
+    assert "headers_env: OTEL_EXPORTER_OTLP_HEADERS" in config
+    assert "traces: true" in config
+    assert "metrics: true" in config
+    assert "instrument_fastapi: true" in config
+    assert "metrics_export_interval_millis: 15000" in config
+    assert "observability: opentelemetry" in (
+        project_dir / "config" / "adapters" / "adapters.yaml"
+    ).read_text(encoding="utf-8")
+
+    env = (project_dir / ".env").read_text(encoding="utf-8")
+    assert "EXISTING=value" in env
+    assert "OTEL_SERVICE_NAME=demo-api" in env
+    assert "OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318" in env
+    assert "OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf" in env
+    assert "OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer test" in env
+    assert ".env" in (project_dir / ".gitignore").read_text(encoding="utf-8")
+
+
 def test_add_langgraph_agent_adapter_generates_runtime_entrypoint(tmp_path: Path) -> None:
     project_dir = _minimal_project(tmp_path)
 
@@ -242,6 +342,19 @@ def test_add_non_entity_adapter_rejects_entity_selection(tmp_path: Path) -> None
         )
 
 
+def test_add_transport_adapter_rejects_entity_selection(tmp_path: Path) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    with pytest.raises(typer.Exit):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="api",
+            adapter="fastapi",
+            entity_names=["Widget"],
+            yes=True,
+        )
+
+
 def test_add_adapter_rejects_unknown_catalog_param(tmp_path: Path) -> None:
     project_dir = _minimal_project(tmp_path)
 

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/test_capabilities.py

@@ -23,7 +23,7 @@ def test_observability_capability_catalog_declares_langsmith() -> None:
     assert capability is not None
     assert capability.layer == "outbound"
     assert capability.activation_config_key == "observability"
-    assert capability.adapter_names() == ("langsmith",)
+    assert capability.adapter_names() == ("langsmith", "opentelemetry")
     langsmith = capability.get_adapter("langsmith")
     assert langsmith is not None
     assert langsmith.config_path == "config/adapters/outbound/langsmith.yaml"
@@ -37,6 +37,56 @@ def test_observability_capability_catalog_declares_langsmith() -> None:
     ]
 
 
+def test_api_capability_catalog_declares_fastapi() -> None:
+    capability = get_capability("api")
+
+    assert capability is not None
+    assert capability.layer == "inbound"
+    assert capability.activation_config_key is None
+    assert capability.adapter_names() == ("fastapi",)
+    fastapi = capability.get_adapter("fastapi")
+    assert fastapi is not None
+    assert fastapi.config_path == "config/adapters/inbound/fastapi.yaml"
+    assert fastapi.entity_scoped is False
+    assert [parameter.name for parameter in fastapi.parameters] == ["host", "port", "reload"]
+
+
+def test_mcp_capability_catalog_declares_fastmcp() -> None:
+    capability = get_capability("mcp")
+
+    assert capability is not None
+    assert capability.layer == "inbound"
+    assert capability.activation_config_key is None
+    assert capability.adapter_names() == ("fastmcp",)
+    fastmcp = capability.get_adapter("fastmcp")
+    assert fastmcp is not None
+    assert fastmcp.config_path == "config/adapters/inbound/fastmcp.yaml"
+    assert fastmcp.entity_scoped is False
+    assert [parameter.name for parameter in fastmcp.parameters] == ["host", "port"]
+
+
+def test_observability_capability_catalog_declares_opentelemetry() -> None:
+    capability = get_capability("observability")
+
+    assert capability is not None
+    opentelemetry = capability.get_adapter("opentelemetry")
+    assert opentelemetry is not None
+    assert opentelemetry.config_path == "config/adapters/outbound/opentelemetry.yaml"
+    assert opentelemetry.env_path == ".env"
+    assert opentelemetry.entity_scoped is False
+    assert [parameter.name for parameter in opentelemetry.parameters] == [
+        "enabled",
+        "service_name",
+        "endpoint",
+        "protocol",
+        "traces",
+        "metrics",
+        "instrument_fastapi",
+        "metrics_export_interval_millis",
+        "headers",
+    ]
+
+
 def test_agent_capability_catalog_declares_langgraph() -> None:
     capability = get_capability("agent")
 
@@ -89,10 +139,15 @@ def test_capability_catalog_is_json_serializable() -> None:
 
     assert "repository" in encoded
     assert "mongodb" in encoded
+    assert "api" in encoded
+    assert "fastapi" in encoded
+    assert "mcp" in encoded
+    assert "fastmcp" in encoded
     assert "agent" in encoded
     assert "langgraph" in encoded
     assert "observability" in encoded
     assert "langsmith" in encoded
+    assert "opentelemetry" in encoded
 
 
 def test_capabilities_command_outputs_json_catalog() -> None:
@@ -107,7 +162,11 @@ def test_capabilities_command_outputs_json_catalog() -> None:
     payload = json.loads(result.stdout)
     assert payload[0]["name"] == "repository"
     assert [adapter["name"] for adapter in payload[0]["adapters"]] == ["memory", "mongodb", "duckdb", "mariadb"]
-    assert payload[1]["name"] == "agent"
-    assert [adapter["name"] for adapter in payload[1]["adapters"]] == ["langgraph"]
-    assert payload[2]["name"] == "observability"
-    assert [adapter["name"] for adapter in payload[2]["adapters"]] == ["langsmith"]
+    assert payload[1]["name"] == "api"
+    assert [adapter["name"] for adapter in payload[1]["adapters"]] == ["fastapi"]
+    assert payload[2]["name"] == "mcp"
+    assert [adapter["name"] for adapter in payload[2]["adapters"]] == ["fastmcp"]
+    assert payload[3]["name"] == "agent"
+    assert [adapter["name"] for adapter in payload[3]["adapters"]] == ["langgraph"]
+    assert payload[4]["name"] == "observability"
+    assert [adapter["name"] for adapter in payload[4]["adapters"]] == ["langsmith", "opentelemetry"]

arclith_cli-0.10.0/tests/test_core_scaffold.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+import pytest
+import typer
+
+from arclith_cli.core_scaffold import add_entity_cmd, add_usecase_cmd
+
+
+def _src_project(tmp_path: Path, package_name: str = "demo_service") -> Path:
+    project_dir = tmp_path / "demo-service"
+    package_root = project_dir / "src" / package_name
+    package_root.mkdir(parents=True)
+    (package_root / "__init__.py").write_text("", encoding="utf-8")
+    (project_dir / "pyproject.toml").write_text('[project]\nname = "demo-service"\n', encoding="utf-8")
+    return project_dir
+
+
+def test_add_entity_creates_minimal_entity_in_src_package(tmp_path: Path) -> None:
+    project_dir = _src_project(tmp_path)
+
+    generated = add_entity_cmd(project_dir=project_dir, entity_name="ShoppingItem")
+
+    assert generated == project_dir / "src" / "demo_service" / "domain" / "models" / "shopping_item.py"
+    assert generated.read_text(encoding="utf-8") == (
+        "from arclith.domain.models.entity import Entity\n"
+        "\n"
+        "\n"
+        "class ShoppingItem(Entity):\n"
+        "    pass\n"
+    )
+    assert (project_dir / "src" / "demo_service" / "domain" / "__init__.py").exists()
+    assert (project_dir / "src" / "demo_service" / "domain" / "models" / "__init__.py").exists()
+    assert not (project_dir / "src" / "demo_service" / "adapters").exists()
+
+
+def test_add_usecase_creates_minimal_usecase_in_src_package(tmp_path: Path) -> None:
+    project_dir = _src_project(tmp_path)
+
+    generated = add_usecase_cmd(project_dir=project_dir, usecase_name="PlanShoppingList")
+
+    assert generated == project_dir / "src" / "demo_service" / "application" / "use_cases" / "plan_shopping_list.py"
+    assert generated.read_text(encoding="utf-8") == (
+        "class PlanShoppingListUseCase:\n"
+        "    async def execute(self) -> None:\n"
+        '        raise NotImplementedError("Implement PlanShoppingListUseCase.execute")\n'
+    )
+    assert (project_dir / "src" / "demo_service" / "application" / "__init__.py").exists()
+    assert (project_dir / "src" / "demo_service" / "application" / "use_cases" / "__init__.py").exists()
+    assert not (project_dir / "src" / "demo_service" / "adapters").exists()
+
+
+def test_add_usecase_strips_repeated_usecase_suffix(tmp_path: Path) -> None:
+    project_dir = _src_project(tmp_path)
+
+    generated = add_usecase_cmd(project_dir=project_dir, usecase_name="plan-shopping-list-use-case-usecase")
+
+    assert generated.name == "plan_shopping_list.py"
+    assert "class PlanShoppingListUseCase:" in generated.read_text(encoding="utf-8")
+    assert "UseCaseUseCase" not in generated.read_text(encoding="utf-8")
+
+
+def test_add_entity_supports_legacy_root_layout(tmp_path: Path) -> None:
+    project_dir = tmp_path / "legacy-service"
+    project_dir.mkdir(parents=True)
+    (project_dir / "pyproject.toml").write_text('[project]\nname = "legacy-service"\n', encoding="utf-8")
+
+    generated = add_entity_cmd(project_dir=project_dir, entity_name="Recipe")
+
+    assert generated == project_dir / "domain" / "models" / "recipe.py"
+    assert (project_dir / "domain" / "__init__.py").exists()
+    assert (project_dir / "domain" / "models" / "__init__.py").exists()
+    assert not (project_dir / "__init__.py").exists()
+
+
+def test_add_entity_refuses_to_overwrite_existing_file(tmp_path: Path) -> None:
+    project_dir = _src_project(tmp_path)
+    existing = project_dir / "src" / "demo_service" / "domain" / "models" / "recipe.py"
+    existing.parent.mkdir(parents=True)
+    existing.write_text("class Recipe:\n    pass\n", encoding="utf-8")
+
+    with pytest.raises(typer.Exit):
+        add_entity_cmd(project_dir=project_dir, entity_name="Recipe")
+
+    assert existing.read_text(encoding="utf-8") == "class Recipe:\n    pass\n"
+
+
+def test_add_usecase_rejects_invalid_name(tmp_path: Path) -> None:
+    project_dir = _src_project(tmp_path)
+
+    with pytest.raises(typer.Exit):
+        add_usecase_cmd(project_dir=project_dir, usecase_name="123-import")

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/test_e2e_scaffold.py

@@ -136,7 +136,63 @@ def test_scaffold_and_run(temp_workspace: Path):
     for fname in expected_files:
         assert (project_dir / fname).exists(), f"Missing expected file: {fname}"
 
-    # Step 6 — validate non-interactive adapter generation through the CLI entry point
+    # Step 6 — validate core scaffolding through the CLI entry point
+    result = subprocess.run(
+        [
+            "arclith-cli",
+            "add-entity",
+            "ShoppingItem",
+        ],
+        cwd=project_dir,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"add-entity failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+    assert (
+        project_dir / "src" / "test_plan_service" / "domain" / "models" / "shopping_item.py"
+    ).exists()
+
+    result = subprocess.run(
+        [
+            "arclith-cli",
+            "add-usecase",
+            "PlanShoppingList",
+        ],
+        cwd=project_dir,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"add-usecase failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+    assert (
+        project_dir / "src" / "test_plan_service" / "application" / "use_cases" / "plan_shopping_list.py"
+    ).exists()
+
+    import_script = "\n".join(
+        [
+            "from test_plan_service.domain.models.shopping_item import ShoppingItem",
+            "from test_plan_service.application.use_cases.plan_shopping_list import PlanShoppingListUseCase",
+            "print(ShoppingItem.__name__, PlanShoppingListUseCase.__name__)",
+        ]
+    )
+    result = subprocess.run(
+        [
+            "uv",
+            "run",
+            "python",
+            "-c",
+            import_script,
+        ],
+        cwd=project_dir,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, f"Core scaffold import failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+    assert "ShoppingItem PlanShoppingListUseCase" in result.stdout
+
+    # Step 7 — validate non-interactive adapter generation through the CLI entry point
     result = subprocess.run(
         [
             "arclith-cli",

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/test_project_paths.py

@@ -12,11 +12,25 @@ def test_detect_project_paths_uses_src_package(tmp_path: Path):
     assert paths.package_root == package_root
     assert paths.package_name == "my_service"
     assert paths.domain_models == package_root / "domain" / "models"
+    assert paths.application_use_cases == package_root / "application" / "use_cases"
     assert paths.adapters_outbound == package_root / "adapters" / "outbound"
     assert paths.containers == package_root / "infrastructure" / "containers"
     assert paths.import_path("domain", "models", "recipe") == "my_service.domain.models.recipe"
 
 
+def test_detect_project_paths_uses_src_package_before_domain_exists(tmp_path: Path):
+    package_root = tmp_path / "src" / "my_service"
+    package_root.mkdir(parents=True)
+    (package_root / "__init__.py").write_text("", encoding="utf-8")
+
+    paths = detect_project_paths(tmp_path)
+
+    assert paths.package_root == package_root
+    assert paths.package_name == "my_service"
+    assert paths.domain_models == package_root / "domain" / "models"
+    assert paths.application_use_cases == package_root / "application" / "use_cases"
+
+
 def test_detect_project_paths_supports_root_layout(tmp_path: Path):
     (tmp_path / "domain" / "models").mkdir(parents=True)
 
@@ -24,4 +38,6 @@ def test_detect_project_paths_supports_root_layout(tmp_path: Path):
 
     assert paths.package_root == tmp_path
     assert paths.package_name is None
+    assert paths.domain_models == tmp_path / "domain" / "models"
+    assert paths.application_use_cases == tmp_path / "application" / "use_cases"
     assert paths.import_path("domain", "models", "recipe") == "domain.models.recipe"

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/tests/test_rename.py

@@ -1,6 +1,7 @@
+from importlib.metadata import version
 from pathlib import Path
 
-from arclith_cli.rename import EntityNames, apply_rename
+from arclith_cli.rename import EntityNames, _patch_arclith_dependency, apply_rename
 
 
 def test_apply_rename_updates_src_package_and_imports(tmp_path: Path):
@@ -16,6 +17,7 @@ def test_apply_rename_updates_src_package_and_imports(tmp_path: Path):
     pyproject.write_text(
         'name = "arclith-sample"\n'
         'packages = ["src/arclith_sample"]\n'
+        'dependencies = ["arclith[all]>=0.12.0"]\n'
         "[tool.uv.sources]\n"
         'arclith = { path = "../arclith", editable = true }\n',
         encoding="utf-8",
@@ -29,4 +31,13 @@ def test_apply_rename_updates_src_package_and_imports(tmp_path: Path):
     patched_pyproject = pyproject.read_text(encoding="utf-8")
     assert 'name = "my-recipe-service"' in patched_pyproject
     assert 'packages = ["src/my_recipe_service"]' in patched_pyproject
+    assert f'"arclith[all]>={version("arclith")}"' in patched_pyproject
     assert "[tool.uv.sources]" not in patched_pyproject
+
+
+def test_patch_arclith_dependency_keeps_template_requirement_when_version_is_unknown(monkeypatch):
+    monkeypatch.setattr("arclith_cli.rename._installed_arclith_version", lambda: None)
+
+    text = 'dependencies = ["arclith[all]>=0.12.0"]\n'
+
+    assert _patch_arclith_dependency(text) == text

{arclith_cli-0.9.0 → arclith_cli-0.10.0}/uv.lock

@@ -46,7 +46,7 @@ wheels = [
 
 [[package]]
 name = "arclith"
-version = "0.12.0"
+version = "0.13.0"
 source = { editable = "../" }
 dependencies = [
     { name = "fastapi" },
@@ -84,6 +84,16 @@ requires-dist = [
     { name = "loguru", specifier = "==0.7.3" },
     { name = "motor", marker = "extra == 'all'", specifier = "==3.7.1" },
     { name = "motor", marker = "extra == 'mongodb'", specifier = "==3.7.1" },
+    { name = "opentelemetry-api", marker = "extra == 'all'", specifier = ">=1.30.0" },
+    { name = "opentelemetry-api", marker = "extra == 'opentelemetry'", specifier = ">=1.30.0" },
+    { name = "opentelemetry-exporter-otlp", marker = "extra == 'all'", specifier = ">=1.30.0" },
+    { name = "opentelemetry-exporter-otlp", marker = "extra == 'opentelemetry'", specifier = ">=1.30.0" },
+    { name = "opentelemetry-instrumentation-fastapi", marker = "extra == 'all'", specifier = ">=0.51b0" },
+    { name = "opentelemetry-instrumentation-fastapi", marker = "extra == 'opentelemetry'", specifier = ">=0.51b0" },
+    { name = "opentelemetry-instrumentation-logging", marker = "extra == 'all'", specifier = ">=0.51b0" },
+    { name = "opentelemetry-instrumentation-logging", marker = "extra == 'opentelemetry'", specifier = ">=0.51b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'all'", specifier = ">=1.30.0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'opentelemetry'", specifier = ">=1.30.0" },
     { name = "pydantic", specifier = "==2.12.5" },
     { name = "pydantic-ai-slim", extras = ["anthropic", "openai"], marker = "extra == 'all'", specifier = ">=2.24.0,<3.0.0" },
     { name = "pydantic-ai-slim", extras = ["anthropic", "openai"], marker = "extra == 'langgraph'", specifier = ">=2.24.0,<3.0.0" },
@@ -100,7 +110,7 @@ requires-dist = [
     { name = "uvicorn", marker = "extra == 'all'", specifier = "==0.41.0" },
     { name = "uvicorn", marker = "extra == 'fastapi'", specifier = "==0.41.0" },
 ]
-provides-extras = ["mongodb", "duckdb", "mariadb", "fastapi", "mcp", "vault", "cache", "auth", "langgraph", "all"]
+provides-extras = ["mongodb", "duckdb", "mariadb", "fastapi", "mcp", "vault", "cache", "auth", "langgraph", "opentelemetry", "all"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -118,7 +128,7 @@ dev = [
 
 [[package]]
 name = "arclith-cli"
-version = "0.9.0"
+version = "0.10.0"
 source = { editable = "." }
 dependencies = [
     { name = "arclith" },

arclith_cli-0.9.0/arclith_cli/__init__.py

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