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

arclith_cli-0.9.0/LICENSE

@@ -0,0 +1,180 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and its Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of developing and
+      refining the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent contributions
+      Licensable by such Contributor that are necessarily infringed by
+      their Contribution(s) alone or by the combination of their
+      Contribution(s) with the Work to which such Contribution(s) was
+      submitted. If You institute patent litigation against any entity
+      (including a cross-claim or counterclaim in a lawsuit) alleging that
+      the Work or any Contribution embodied within the Work constitutes
+      direct or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate as
+      of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or in addition to the
+          NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the Work.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Liability. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a fee
+      for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may offer only conditions that
+      You alone are responsible for, and not on behalf of any other
+      Contributor.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Killian KOPP
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arclith-cli
-Version: 0.7.1
+Version: 0.9.0
 Summary: CLI scaffolding tool for arclith — hexagonal architecture framework
 Author-email: Killian KOPP <killiankopp@gmail.com>
 License:                                  Apache License
@@ -183,9 +183,10 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
         
+License-File: LICENSE
 Keywords: arclith,cli,ddd,hexagonal-architecture,scaffold
 Requires-Python: >=3.13
-Requires-Dist: arclith>=0.7.0
+Requires-Dist: arclith>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

arclith_cli-0.9.0/README.md

@@ -0,0 +1,205 @@
+# arclith-cli
+
+`arclith-cli` génère instantanément un projet Python en architecture hexagonale prêt à démarrer, en téléchargeant le template officiel `_sample` depuis GitHub et en remplaçant l'entité de démo `Ingredient` par le nom de votre choix. Tout type de projet peut être scaffoldé — service REST, agent IA, API MCP — avec les ports, le nom de projet et le backend de persistance configurés d'emblée.
+
+## Installation
+
+```bash
+uv tool install "git+https://github.com/karned-rekipe/arclith.git#subdirectory=cli"
+```
+
+## Commandes
+
+### `new` — Créer un projet
+
+Scaffold un nouveau projet arclith depuis le template officiel `_sample`.
+
+```bash
+# Mode interactif — l'outil pose les questions
+arclith-cli new
+
+# Mode direct
+arclith-cli new Recipe my-recipe-service
+arclith-cli new RecipeStep meal-planner --port 8400
+arclith-cli new MealPlan meal-plan-service --dir ~/projects --port 8500
+```
+
+| Option | Défaut | Description |
+|--------|--------|-------------|
+| `--port` / `-p` | `8000` | Port REST (MCP = port+1) |
+| `--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)).
+
+---
+
+### `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`.
+
+```bash
+cd my-recipe-service
+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 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 agent --adapter langgraph --param graph_name=recipe_agent --yes
+arclith-cli add-adapter --capability observability --adapter langsmith
+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`
+3. **Paramètres** — questions spécifiques à l'adapter :
+   - `mongodb` → `db_name`, `multitenant`
+   - `duckdb` → `path`
+   - `mariadb` → `host`, `port`, `database`, `user`, `driver`, `table_prefix`
+   - `langgraph` → `graph_name`
+   - `langsmith` → `tracing`, `project`, `endpoint`, `LANGSMITH_API_KEY`
+   - `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`
+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` |
+| `--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 |
+| `--db-name` | nom du projet | Nom de base pour MongoDB |
+| `--multitenant/--single-tenant` | `--single-tenant` | Mode MongoDB multitenant |
+| `--path` | `data/` | Chemin DuckDB |
+| `--param` | - | Paramètre adapter `key=value`, répétable pour les adapters du catalogue |
+| `--yes` / `-y` | `false` | Skip la confirmation et utilise les valeurs fournies ou par défaut |
+
+**Fichiers générés par entité :**
+
+```
+config/adapters/outbound/<adapter>.yaml          # config scopée si l'adapter en a besoin
+src/<package>/adapters/outbound/<adapter>/__init__.py
+src/<package>/adapters/outbound/<adapter>/repository.py        # re-export
+src/<package>/adapters/outbound/<adapter>/repositories/<entity>_repository.py  # sous-classe à compléter
+src/<package>/infrastructure/containers/<entity>_container.py  # RepositoryRegistry régénéré
+```
+
+> ⚠️ `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.
+
+**LangGraph / LangSmith :**
+
+```bash
+uv add "arclith[langgraph]"
+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 `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
+à 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.
+
+Parcours complet avec entité, API, LangGraph, LangSmith et LM Studio:
+[`docs/agent-quickstart.md`](../docs/agent-quickstart.md).
+
+---
+
+### `capabilities` — Lister le catalogue standardisé
+
+Affiche les capacités et adapters connus par la CLI.
+
+```bash
+arclith-cli capabilities
+arclith-cli capabilities --json
+```
+
+Le catalogue est la source de vérité pour les adapters supportés, leurs paramètres, leur chemin de configuration et la clé d'activation.
+
+---
+
+### `export-config` — Générer `config.yaml` pour K8s
+
+Fusionne le dossier `config/` en un fichier YAML unique, à lancer **depuis la racine du projet**.
+
+```bash
+arclith-cli export-config                        # → ./config.yaml
+arclith-cli export-config --output dist/app.yaml # chemin personnalisé
+```
+
+Le fichier généré peut être monté directement comme **ConfigMap** Kubernetes.
+Arclith le lit au même titre que le dossier `config/` :
+
+```python
+# dev
+arclith = Arclith("config/")
+
+# K8s (ConfigMap monté sur /app/config.yaml)
+arclith = Arclith("config.yaml")
+```
+
+> ⚠️ `config.yaml` est un **artefact généré** — l'ajouter à `.gitignore`.
+> La source de vérité reste `config/`.
+
+---
+
+### `update` — Mettre à jour le CLI
+
+```bash
+arclith-cli update
+```
+
+### `version` — Afficher la version
+
+```bash
+arclith-cli version
+```
+
+---
+
+## Configuration
+
+Les projets arclith utilisent un dossier `config/` à la place d'un `config.yaml` monolithique. Chaque fichier est **scopé** : son chemin détermine la section `AppConfig` dans laquelle son contenu est injecté.
+
+```
+config/
+  app.yaml                        # app: { name, version, description }
+  soft_delete.yaml                # soft_delete: { retention_days }
+  secrets.yaml                    # secrets: { resolver, mappings, vault, yaml }
+  adapters/
+    adapters.yaml                 # adapters: { logger, repository }   ← adapter actif
+    outbound/
+      mongodb.yaml                # adapters.mongodb: { db_name, multitenant }
+      duckdb.yaml                 # adapters.duckdb: { path, multitenant }
+      mariadb.yaml                # adapters.mariadb: { host, port, database, user, ... }
+      langsmith.yaml              # adapters.langsmith: { tracing, project, endpoint, ... }
+    inbound/
+      fastapi.yaml                # api: { host, port, reload }
+      fastmcp.yaml                # mcp: { host, port }
+      probe.yaml                  # probe: { host, port, enabled }
+      keycloak.yaml               # keycloak: { url, realm }
+      tenant.yaml                 # tenant: { vault_addr, … }
+      license.yaml                # license: { role }
+      cache.yaml                  # cache: { backend, redis_url, … }
+```
+
+Pour changer l'adapter actif sans passer par le wizard :
+
+```yaml
+# config/adapters/adapters.yaml
+repository: duckdb   # memory | mongodb | duckdb | mariadb
+observability: langsmith
+```
+
+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.9.0/arclith_cli/__init__.py

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

arclith_cli-0.9.0/arclith_cli/adapter_templates.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from typing import Any
+
+# ── Python repository subclass templates ─────────────────────────────────────
+
+REPO_PYTHON: dict[str, str] = {
+    "memory": """\
+from arclith.adapters.outbound.memory.repository import InMemoryRepository
+from {domain_import}.models.{snake} import {pascal}
+from {domain_import}.ports.outbound.{snake}_repository import {pascal}Repository
+
+
+class InMemory{pascal}Repository(InMemoryRepository[{pascal}], {pascal}Repository):
+    pass  # TODO: add custom query methods if needed
+""",
+    "mongodb": """\
+from arclith.adapters.outbound.mongodb.config import MongoDBConfig
+from arclith.adapters.outbound.mongodb.repository import MongoDBRepository
+from arclith.domain.ports.outbound.logger import Logger
+from {domain_import}.models.{snake} import {pascal}
+from {domain_import}.ports.outbound.{snake}_repository import {pascal}Repository
+
+
+class MongoDB{pascal}Repository(MongoDBRepository[{pascal}], {pascal}Repository):
+    def __init__(self, config: MongoDBConfig, logger: Logger) -> None:
+        super().__init__(config, {pascal}, logger)
+
+    # TODO: add custom query methods here
+    # async def find_by_name(self, name: str) -> list[{pascal}]:
+    #     async with self._collection() as col:
+    #         return [
+    #             self._from_doc(doc)
+    #             async for doc in col.find({{"name": name, "deleted_at": None}})
+    #         ]
+""",
+    "duckdb": """\
+from arclith.adapters.outbound.duckdb.repository import DuckDBRepository
+from {domain_import}.models.{snake} import {pascal}
+from {domain_import}.ports.outbound.{snake}_repository import {pascal}Repository
+
+
+class DuckDB{pascal}Repository(DuckDBRepository[{pascal}], {pascal}Repository):
+    def __init__(self, path: str) -> None:
+        super().__init__(path, {pascal})
+
+    # TODO: add custom query methods here
+    # async def find_by_name(self, name: str) -> list[{pascal}]:
+    #     rows = self._fetch(
+    #         f"SELECT * FROM {{self._table}} WHERE deleted_at IS NULL AND lower(name) LIKE ?",
+    #         [f"%{{name.lower()}}%"],
+    #     )
+    #     return [self._row_to_entity(r) for r in rows]
+""",
+    "mariadb": """\
+from arclith.adapters.outbound.mariadb.config import MariaDBConfig
+from arclith.adapters.outbound.mariadb.repository import MariaDBRepository
+from arclith.domain.ports.outbound.logger import Logger
+from {domain_import}.models.{snake} import {pascal}
+from {domain_import}.ports.outbound.{snake}_repository import {pascal}Repository
+
+
+class MariaDB{pascal}Repository(MariaDBRepository[{pascal}], {pascal}Repository):
+    def __init__(self, config: MariaDBConfig, logger: Logger) -> None:
+        super().__init__(config, {pascal}, logger)
+
+    # TODO: add custom query methods here
+""",
+}
+
+# ── repository.py re-export template ─────────────────────────────────────────
+
+REPO_REEXPORT: dict[str, str] = {
+    "memory": """\
+from {adapters_import}.outbound.memory.repositories.{snake}_repository import InMemory{pascal}Repository
+
+__all__ = ["InMemory{pascal}Repository"]
+""",
+    "mongodb": """\
+from {adapters_import}.outbound.mongodb.repositories.{snake}_repository import MongoDB{pascal}Repository
+
+__all__ = ["MongoDB{pascal}Repository"]
+""",
+    "duckdb": """\
+from {adapters_import}.outbound.duckdb.repositories.{snake}_repository import DuckDB{pascal}Repository
+
+__all__ = ["DuckDB{pascal}Repository"]
+""",
+    "mariadb": """\
+from {adapters_import}.outbound.mariadb.repositories.{snake}_repository import MariaDB{pascal}Repository
+
+__all__ = ["MariaDB{pascal}Repository"]
+""",
+}
+
+# ── Container template (full file, regenerated with all installed adapters) ───
+
+_CONTAINER_HEADER = """\
+from {application_import}.services.{snake}_service import {pascal}Service
+from arclith import Arclith, RepositoryRegistry
+from arclith.domain.ports.outbound.logger import Logger
+from arclith.infrastructure.config import AppConfig
+from {domain_import}.models.{snake} import {pascal}
+from {domain_import}.ports.outbound.{snake}_repository import {pascal}Repository
+
+"""
+
+_CONTAINER_FACTORY: dict[str, str] = {
+    "memory": """\
+def _build_memory(_cfg: AppConfig, _entity_class: type[{pascal}], _log: Logger) -> {pascal}Repository:
+    from {adapters_import}.outbound.memory.repository import InMemory{pascal}Repository
+    return InMemory{pascal}Repository()
+
+""",
+    "mongodb": """\
+def _build_mongodb(cfg: AppConfig, _entity_class: type[{pascal}], log: Logger) -> {pascal}Repository:
+    from {adapters_import}.outbound.mongodb.repository import MongoDB{pascal}Repository
+    from arclith.adapters.outbound.mongodb.config import MongoDBConfig
+    mongo = cfg.adapters.mongodb
+    if mongo is None:
+        raise ValueError("MongoDB settings are required when repository=mongodb")
+    return MongoDB{pascal}Repository(MongoDBConfig(uri=mongo.uri, db_name=mongo.db_name), log)
+
+""",
+    "duckdb": """\
+def _build_duckdb(cfg: AppConfig, _entity_class: type[{pascal}], _log: Logger) -> {pascal}Repository:
+    from {adapters_import}.outbound.duckdb.repository import DuckDB{pascal}Repository
+    duckdb = cfg.adapters.duckdb
+    if duckdb is None:
+        raise ValueError("DuckDB settings are required when repository=duckdb")
+    return DuckDB{pascal}Repository(duckdb.path)
+
+""",
+    "mariadb": """\
+def _build_mariadb(cfg: AppConfig, _entity_class: type[{pascal}], log: Logger) -> {pascal}Repository:
+    from {adapters_import}.outbound.mariadb.repository import MariaDB{pascal}Repository
+    from arclith.adapters.outbound.mariadb.config import MariaDBConfig
+    mariadb = cfg.adapters.mariadb
+    if mariadb is None:
+        raise ValueError("MariaDB settings are required when repository=mariadb")
+    return MariaDB{pascal}Repository(
+        MariaDBConfig(
+            url=mariadb.url,
+            host=mariadb.host,
+            port=mariadb.port,
+            database=mariadb.database,
+            user=mariadb.user,
+            password=mariadb.password,
+            driver=mariadb.driver,
+            table_prefix=mariadb.table_prefix,
+        ),
+        log,
+    )
+
+""",
+}
+
+_CONTAINER_FOOTER = """\
+_repository_registry: RepositoryRegistry[{pascal}, {pascal}Repository] = (
+    RepositoryRegistry[{pascal}, {pascal}Repository]()
+{registrations}
+)
+
+
+def build_{snake}_service(arclith: Arclith) -> tuple[{pascal}Service, Logger]:
+    arclith.logger.info("🗄️ Repository adapter selected", adapter=arclith.config.adapters.repository)
+    repo: {pascal}Repository = arclith.repository({pascal}, registry=_repository_registry)
+    return {pascal}Service(repo, arclith.logger, arclith.config.soft_delete.retention_days), arclith.logger
+"""
+
+
+def render_container(pascal: str, snake: str, installed_adapters: list[str], import_vars: dict[str, str]) -> str:
+    """Generate the full container file content for a given entity and its adapters."""
+    # memory is always included (arclith built-in, needs no extra files)
+    adapters = list(dict.fromkeys(["memory"] + installed_adapters))
+    vars = {"pascal": pascal, "snake": snake, **import_vars}
+
+    header = _CONTAINER_HEADER.format(**vars)
+    factories = "".join(
+        _CONTAINER_FACTORY[a].format(**vars)
+        for a in adapters
+        if a in _CONTAINER_FACTORY
+    )
+    registrations = "\n".join(
+        f"    .register(\"{a}\", _build_{a})"
+        for a in adapters
+        if a in _CONTAINER_FACTORY
+    )
+    footer = _CONTAINER_FOOTER.format(**vars, registrations=registrations)
+    return header + factories + footer
+
+
+def render(template: str, vars: dict[str, Any]) -> str:
+    return template.format(**vars)