arclith-cli 0.19.0__tar.gz → 0.20.0__tar.gz

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arclith-cli
-Version: 0.19.0
+Version: 0.20.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.22.0
+Requires-Dist: arclith>=0.23.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

arclith_cli-0.20.0/arclith_cli/__init__.py

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

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/adapter_templates.py

@@ -205,7 +205,8 @@ _repository_registry: RepositoryRegistry[{pascal}, {pascal}Repository] = (
 
 
 def build_{snake}_service(arclith: Arclith) -> tuple[{pascal}Service, Logger]:
-    arclith.logger.info("🗄️ Repository adapter selected", adapter=arclith.config.adapters.repository)
+    adapter = arclith.config.adapters.repository_adapter_for({pascal})
+    arclith.logger.info("🗄️ Repository adapter selected", adapter=adapter)
     repo: {pascal}Repository = arclith.repository({pascal}, registry=_repository_registry)
     return {pascal}Service(repo, arclith.logger, arclith.config.soft_delete.retention_days), arclith.logger
 """

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/capabilities.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any
 
 from arclith_cli.capability_models import (
+    AdapterFacets,
     AdapterProfileSpec,
     AdapterSpec,
     CapabilitySpec,
@@ -18,6 +19,7 @@ from arclith_cli.catalogs.ai import (
     EMBEDDING_CAPABILITY,
     LLM_CAPABILITY,
 )
+from arclith_cli.catalogs.channels import CHANNEL_CAPABILITY
 from arclith_cli.catalogs.core import (
     CACHE_CAPABILITY,
     LOGGER_CAPABILITY,
@@ -48,9 +50,11 @@ __all__ = [
     "AGENT_PERSISTENCE_CAPABILITY",
     "API_CAPABILITY",
     "AUTH_CAPABILITY",
+    "AdapterFacets",
     "AdapterProfileSpec",
     "AdapterSpec",
     "CACHE_CAPABILITY",
+    "CHANNEL_CAPABILITY",
     "CAPABILITY_CATALOG",
     "COMMAND_BUS_CAPABILITY",
     "CapabilitySpec",
@@ -91,6 +95,7 @@ CAPABILITY_CATALOG = (
     PROBE_CAPABILITY,
     HTTP_CAPABILITY,
     COMMAND_BUS_CAPABILITY,
+    CHANNEL_CAPABILITY,
     RUNTIME_CAPABILITY,
     AUTH_CAPABILITY,
     TENANT_CAPABILITY,

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/capability_models.py

@@ -5,6 +5,16 @@ from typing import Any, Literal
 
 ParameterKind = Literal["string", "boolean"]
 LayerKind = Literal["inbound", "outbound", "bidirectional", "runtime"]
+StorageModel = Literal[
+    "memory",
+    "document",
+    "relational_json",
+    "embedded_analytics",
+    "relational_structured",
+]
+RuntimeKind = Literal["in_process", "file", "server"]
+TransactionSupport = Literal["none", "limited", "strong"]
+SchemaStrategy = Literal["flexible", "json_table", "structured_tables"]
 
 
 @dataclass(frozen=True)
@@ -70,6 +80,30 @@ class AdapterProfileSpec:
         return {"name": self.name, "parameters": dict(self.parameters)}
 
 
+@dataclass(frozen=True)
+class AdapterFacets:
+    storage_model: StorageModel
+    runtime: RuntimeKind
+    production_ready: bool
+    multi_process: bool
+    transactions: TransactionSupport
+    schema_strategy: SchemaStrategy
+    recommended_for: tuple[str, ...]
+    limits: tuple[str, ...]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "storage_model": self.storage_model,
+            "runtime": self.runtime,
+            "production_ready": self.production_ready,
+            "multi_process": self.multi_process,
+            "transactions": self.transactions,
+            "schema_strategy": self.schema_strategy,
+            "recommended_for": list(self.recommended_for),
+            "limits": list(self.limits),
+        }
+
+
 @dataclass(frozen=True)
 class AdapterSpec:
     name: str
@@ -90,6 +124,7 @@ class AdapterSpec:
     profiles: tuple[AdapterProfileSpec, ...] = ()
     dependency_extra: str | None = None
     entity_scoped: bool = True
+    facets: AdapterFacets | None = None
 
     def has_config(self) -> bool:
         return self.config_path is not None and bool(self.config_template)
@@ -137,6 +172,7 @@ class AdapterSpec:
             "profiles": [profile.to_dict() for profile in self.profiles],
             "dependency_extra": self.dependency_extra,
             "entity_scoped": self.entity_scoped,
+            "facets": self.facets.to_dict() if self.facets is not None else None,
         }
 
 
@@ -169,6 +205,7 @@ class CapabilitySpec:
 
 
 __all__ = [
+    "AdapterFacets",
     "AdapterProfileSpec",
     "AdapterSpec",
     "CapabilitySpec",
@@ -176,5 +213,9 @@ __all__ = [
     "LayerKind",
     "ParameterKind",
     "ParameterSpec",
+    "RuntimeKind",
+    "SchemaStrategy",
     "SecretMappingSpec",
+    "StorageModel",
+    "TransactionSupport",
 ]

arclith_cli-0.20.0/arclith_cli/catalogs/channels.py

@@ -0,0 +1,197 @@
+from arclith_cli.capability_models import (
+    AdapterSpec,
+    CapabilitySpec,
+    ParameterSpec,
+    SecretMappingSpec,
+)
+
+CHANNEL_CAPABILITY = CapabilitySpec(
+    name="channel",
+    layer="bidirectional",
+    description="Messages conversationnels entrants et sortants normalisés.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="memory",
+            capability="channel",
+            layer="bidirectional",
+            description="Fake déterministe en mémoire pour tests et prototypes locaux.",
+            config_path="config/adapters/bidirectional/memory.yaml",
+            config_template="""\
+enabled: true
+""",
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="webhook",
+            capability="channel",
+            layer="bidirectional",
+            description="Webhook HTTP générique signé, idempotent et provider-neutral.",
+            config_path="config/adapters/bidirectional/webhook.yaml",
+            config_template="""\
+enabled: true
+path: "{path}"
+secret: null
+signature_header: "{signature_header}"
+timestamp_header: "{timestamp_header}"
+signature_tolerance_seconds: {signature_tolerance_seconds}
+idempotency_header: "{idempotency_header}"
+event_ttl_seconds: {event_ttl_seconds}
+max_payload_bytes: {max_payload_bytes}
+metadata_allowlist: []
+response_mode: "{response_mode}"
+callback_url: {callback_url}
+callback_allowed_host: {callback_allowed_host}
+callback_timeout_seconds: {callback_timeout_seconds}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.channel.webhook.secret",
+                    secret_key="ARCLITH_WEBHOOK_SECRET",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="path",
+                    kind="string",
+                    prompt="Route HTTP statique du webhook",
+                    default="/channels/webhook",
+                ),
+                ParameterSpec(
+                    name="signature_header",
+                    kind="string",
+                    prompt="Header de signature HMAC",
+                    default="X-Arclith-Signature",
+                ),
+                ParameterSpec(
+                    name="timestamp_header",
+                    kind="string",
+                    prompt="Header du timestamp signé",
+                    default="X-Arclith-Timestamp",
+                ),
+                ParameterSpec(
+                    name="signature_tolerance_seconds",
+                    kind="string",
+                    prompt="Tolérance de fraîcheur HMAC en secondes",
+                    default="300",
+                ),
+                ParameterSpec(
+                    name="idempotency_header",
+                    kind="string",
+                    prompt="Header de l'identifiant stable de l'événement",
+                    default="X-Arclith-Event-Id",
+                ),
+                ParameterSpec(
+                    name="event_ttl_seconds",
+                    kind="string",
+                    prompt="Durée de déduplication en secondes",
+                    default="86400",
+                ),
+                ParameterSpec(
+                    name="max_payload_bytes",
+                    kind="string",
+                    prompt="Taille maximale du payload en octets",
+                    default="1048576",
+                ),
+                ParameterSpec(
+                    name="response_mode",
+                    kind="string",
+                    prompt="Mode de réponse HTTP",
+                    default="sync",
+                    choices=("sync", "accepted", "callback"),
+                ),
+                ParameterSpec(
+                    name="callback_url",
+                    kind="string",
+                    prompt="URL HTTPS du callback côté serveur (null hors mode callback)",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="callback_allowed_host",
+                    kind="string",
+                    prompt="Hostname exact autorisé pour le callback (null hors mode callback)",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="callback_timeout_seconds",
+                    kind="string",
+                    prompt="Timeout du callback sortant en secondes",
+                    default="5.0",
+                ),
+            ),
+            dependency_extra="channel",
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="slack",
+            capability="channel",
+            layer="bidirectional",
+            description="Slack Events API signé avec réponses chat.postMessage.",
+            config_path="config/adapters/bidirectional/slack.yaml",
+            config_template="""\
+enabled: true
+path: "{path}"
+signing_secret: null
+bot_token: null
+workspace_id: {workspace_id}
+allowed_channel_ids: []
+signature_tolerance_seconds: {signature_tolerance_seconds}
+event_ttl_seconds: {event_ttl_seconds}
+max_payload_bytes: {max_payload_bytes}
+request_timeout_seconds: {request_timeout_seconds}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.channel.slack.signing_secret",
+                    secret_key="ARCLITH_SLACK_SIGNING_SECRET",
+                ),
+                SecretMappingSpec(
+                    field_path="adapters.channel.slack.bot_token",
+                    secret_key="ARCLITH_SLACK_BOT_TOKEN",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="path",
+                    kind="string",
+                    prompt="Route HTTP statique des événements Slack",
+                    default="/channels/slack/events",
+                ),
+                ParameterSpec(
+                    name="workspace_id",
+                    kind="string",
+                    prompt="Workspace Slack exact autorisé (null pour tout accepter)",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="signature_tolerance_seconds",
+                    kind="string",
+                    prompt="Tolérance de fraîcheur de signature en secondes",
+                    default="300",
+                ),
+                ParameterSpec(
+                    name="event_ttl_seconds",
+                    kind="string",
+                    prompt="Durée de déduplication des event_id en secondes",
+                    default="86400",
+                ),
+                ParameterSpec(
+                    name="max_payload_bytes",
+                    kind="string",
+                    prompt="Taille maximale du payload en octets",
+                    default="1048576",
+                ),
+                ParameterSpec(
+                    name="request_timeout_seconds",
+                    kind="string",
+                    prompt="Timeout de chat.postMessage en secondes",
+                    default="5.0",
+                ),
+            ),
+            dependency_extra="channel",
+            entity_scoped=False,
+        ),
+    ),
+)
+
+__all__ = ["CHANNEL_CAPABILITY"]

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/catalogs/persistence.py

@@ -6,6 +6,13 @@ from arclith_cli.capability_models import (
     ParameterSpec,
     SecretMappingSpec,
 )
+from arclith_cli.catalogs.repository_facets import (
+    DUCKDB_FACETS,
+    MARIADB_FACETS,
+    MEMORY_FACETS,
+    MONGODB_FACETS,
+    POSTGRESQL_FACETS,
+)
 
 REPOSITORY_CAPABILITY = CapabilitySpec(
     name="repository",
@@ -18,6 +25,7 @@ REPOSITORY_CAPABILITY = CapabilitySpec(
             capability="repository",
             layer="outbound",
             description="Stockage volatile en mémoire pour dev, tests et smoke locaux.",
+            facets=MEMORY_FACETS,
         ),
         AdapterSpec(
             name="mongodb",
@@ -57,6 +65,7 @@ multitenant: {multitenant}   # true = uri/db_name résolus par requête via JWT
                     default=False,
                 ),
             ),
+            facets=MONGODB_FACETS,
         ),
         AdapterSpec(
             name="duckdb",
@@ -76,6 +85,7 @@ path: {path}
                     default="data/",
                 ),
             ),
+            facets=DUCKDB_FACETS,
         ),
         AdapterSpec(
             name="mariadb",
@@ -142,6 +152,7 @@ multitenant: false
                     default="",
                 ),
             ),
+            facets=MARIADB_FACETS,
         ),
         AdapterSpec(
             name="postgresql",
@@ -221,6 +232,7 @@ multitenant: {multitenant}
                     default=False,
                 ),
             ),
+            facets=POSTGRESQL_FACETS,
         ),
     ),
 )

arclith_cli-0.20.0/arclith_cli/catalogs/repository_facets.py

@@ -0,0 +1,94 @@
+from arclith_cli.capability_models import AdapterFacets
+
+MEMORY_FACETS = AdapterFacets(
+    storage_model="memory",
+    runtime="in_process",
+    production_ready=False,
+    multi_process=False,
+    transactions="none",
+    schema_strategy="flexible",
+    recommended_for=(
+        "tests unitaires",
+        "développement et smoke dans un seul processus",
+    ),
+    limits=(
+        "données perdues à l'arrêt",
+        "état non partagé entre processus",
+    ),
+)
+
+MONGODB_FACETS = AdapterFacets(
+    storage_model="document",
+    runtime="server",
+    production_ready=True,
+    multi_process=True,
+    transactions="limited",
+    schema_strategy="flexible",
+    recommended_for=(
+        "API, MCP et agents avec état partagé",
+        "données métier document-first ou à schéma évolutif",
+    ),
+    limits=(
+        "pas de modèle relationnel riche via Repository[T]",
+        "pas de transaction multi-opérations exposée par le port",
+    ),
+)
+
+DUCKDB_FACETS = AdapterFacets(
+    storage_model="embedded_analytics",
+    runtime="file",
+    production_ready=False,
+    multi_process=False,
+    transactions="limited",
+    schema_strategy="structured_tables",
+    recommended_for=(
+        "démonstrations et traitements analytiques locaux",
+        "données persistées dans des fichiers locaux",
+    ),
+    limits=(
+        "pas conçu comme base applicative serveur multi-process",
+        "concurrence d'écriture et formats de fichier à encadrer",
+    ),
+)
+
+MARIADB_FACETS = AdapterFacets(
+    storage_model="relational_json",
+    runtime="server",
+    production_ready=True,
+    multi_process=True,
+    transactions="strong",
+    schema_strategy="json_table",
+    recommended_for=(
+        "SI existant basé sur MariaDB",
+        "état partagé nécessitant un serveur SQL",
+    ),
+    limits=(
+        "entité stockée comme payload JSON générique",
+        "pas de relations, joins ou migrations métier via le port",
+    ),
+)
+
+POSTGRESQL_FACETS = AdapterFacets(
+    storage_model="relational_json",
+    runtime="server",
+    production_ready=True,
+    multi_process=True,
+    transactions="strong",
+    schema_strategy="json_table",
+    recommended_for=(
+        "services nécessitant un SQL serveur robuste",
+        "état partagé multi-process avec payload JSONB",
+    ),
+    limits=(
+        "entité stockée comme payload JSONB générique",
+        "pas de relations, joins ou migrations métier via le port",
+    ),
+)
+
+__all__ = [
+    "DUCKDB_FACETS",
+    "MARIADB_FACETS",
+    "MEMORY_FACETS",
+    "MONGODB_FACETS",
+    "POSTGRESQL_FACETS",
+]

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/init_project.py

@@ -81,7 +81,7 @@ def _framework_version() -> str:
     try:
         return version("arclith")
     except PackageNotFoundError:
-        return "0.22.0"
+        return "0.23.0"
 
 
 def _create_package_layout(package_root: Path) -> None:

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/arclith_cli/project_paths.py

@@ -32,6 +32,10 @@ class ProjectPaths:
     def adapters_inbound(self) -> Path:
         return self.package_root / "adapters" / "inbound"
 
+    @property
+    def adapters_bidirectional(self) -> Path:
+        return self.package_root / "adapters" / "bidirectional"
+
     @property
     def containers(self) -> Path:
         return self.package_root / "infrastructure" / "containers"
@@ -52,7 +56,11 @@ def detect_project_paths(project_dir: Path) -> ProjectPaths:
         )
         if model_candidates:
             package_root = model_candidates[0]
-            return ProjectPaths(root=project_dir, package_root=package_root, package_name=package_root.name)
+            return ProjectPaths(
+                root=project_dir,
+                package_root=package_root,
+                package_name=package_root.name,
+            )
 
         package_candidates = sorted(
             child
@@ -61,7 +69,11 @@ def detect_project_paths(project_dir: Path) -> ProjectPaths:
         )
         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=package_root,
+                package_name=package_root.name,
+            )
 
     return ProjectPaths(root=project_dir, package_root=project_dir, package_name=None)
 
@@ -70,4 +82,7 @@ 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"))
+    return any(
+        (path / layer).is_dir()
+        for layer in ("domain", "application", "adapters", "infrastructure")
+    )

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arclith-cli"
-version = "0.19.0"
+version = "0.20.0"
 description = "CLI scaffolding tool for arclith — hexagonal architecture framework"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,7 +17,7 @@ dependencies = [
     "typer>=0.15.0",
     "rich>=13.0.0",
     "httpx>=0.27.0",
-    "arclith>=0.22.0",
+    "arclith>=0.23.0",
 ]
 
 [tool.uv.sources]

{arclith_cli-0.19.0 → arclith_cli-0.20.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.22.0"
+MIN_ARCLITH_VERSION="0.23.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.20.0/tests/test_adapter_templates.py

@@ -0,0 +1,20 @@
+from arclith_cli.adapter_templates import render_container
+
+
+def test_generated_container_logs_entity_repository_binding() -> None:
+    rendered = render_container(
+        "ChatThread",
+        "chat_thread",
+        ["mongodb"],
+        {
+            "application_import": "chat_service.application",
+            "domain_import": "chat_service.domain",
+            "adapters_import": "chat_service.adapters",
+        },
+    )
+
+    assert (
+        "adapter = arclith.config.adapters.repository_adapter_for(ChatThread)"
+        in rendered
+    )
+    assert "adapter=adapter)" in rendered

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_add_adapter.py

@@ -520,7 +520,7 @@ def test_add_langsmith_adds_dependency_extra_idempotently(tmp_path: Path) -> Non
     project_dir = _minimal_project(tmp_path)
     pyproject = project_dir / "pyproject.toml"
     pyproject.write_text(
-        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.22.0"]\n',
+        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.23.0"]\n',
         encoding="utf-8",
     )
 
@@ -533,7 +533,7 @@ def test_add_langsmith_adds_dependency_extra_idempotently(tmp_path: Path) -> Non
             yes=True,
         )
 
-    assert "arclith[fastapi,mcp,langsmith]>=0.22.0" in pyproject.read_text()
+    assert "arclith[fastapi,mcp,langsmith]>=0.23.0" in pyproject.read_text()
 
 
 def test_add_opentelemetry_adds_dependency_extra_idempotently(
@@ -542,7 +542,7 @@ def test_add_opentelemetry_adds_dependency_extra_idempotently(
     project_dir = _minimal_project(tmp_path)
     pyproject = project_dir / "pyproject.toml"
     pyproject.write_text(
-        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.22.0"]\n',
+        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.23.0"]\n',
         encoding="utf-8",
     )
 
@@ -555,7 +555,7 @@ def test_add_opentelemetry_adds_dependency_extra_idempotently(
             yes=True,
         )
 
-    assert "arclith[fastapi,mcp,opentelemetry]>=0.22.0" in pyproject.read_text()
+    assert "arclith[fastapi,mcp,opentelemetry]>=0.23.0" in pyproject.read_text()
 
 
 @pytest.mark.parametrize(
@@ -1032,6 +1032,165 @@ def test_add_command_bus_rabbitmq_adapter_rejects_unbounded_prefetch(
     assert not command_bus_path.exists()
 
 
+def test_add_memory_channel_generates_loadable_bidirectional_config(
+    tmp_path: Path,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="channel",
+            adapter="memory",
+            yes=True,
+        )
+
+    from arclith import Arclith, MemoryChannel
+
+    config_path = project_dir / "config" / "adapters" / "bidirectional" / "memory.yaml"
+    app = Arclith(project_dir / "config")
+
+    assert config_path.read_text(encoding="utf-8") == "enabled: true\n"
+    assert app.config.adapters.channel.configured_adapters() == ("memory",)
+    assert isinstance(app.channel_sender("memory"), MemoryChannel)
+    assert not (
+        project_dir / "src" / "demo_service" / "adapters" / "bidirectional" / "memory"
+    ).exists()
+
+
+def test_add_webhook_channel_generates_safe_loadable_config(
+    tmp_path: Path,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+    pyproject = project_dir / "pyproject.toml"
+    pyproject.write_text(
+        '[project]\ndependencies = ["arclith[fastapi]>=0.23.0"]\n',
+        encoding="utf-8",
+    )
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="channel",
+            adapter="webhook",
+            adapter_params={
+                "path": "/integrations/arclith",
+                "signature_tolerance_seconds": "120",
+                "event_ttl_seconds": "7200",
+                "max_payload_bytes": "65536",
+            },
+            yes=True,
+        )
+
+    from arclith import Arclith
+
+    config_path = project_dir / "config" / "adapters" / "bidirectional" / "webhook.yaml"
+    config = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+    app = Arclith(project_dir / "config")
+    secrets = yaml.safe_load(
+        (project_dir / "config" / "secrets.yaml").read_text(encoding="utf-8")
+    )
+
+    assert config["path"] == "/integrations/arclith"
+    assert config["secret"] is None
+    assert config["signature_tolerance_seconds"] == 120
+    assert config["event_ttl_seconds"] == 7200
+    assert config["max_payload_bytes"] == 65536
+    assert config["response_mode"] == "sync"
+    assert app.config.adapters.channel.configured_adapters() == ("webhook",)
+    assert app.config.adapters.channel.webhook is not None
+    assert secrets == {
+        "resolver": "env",
+        "mappings": {
+            "adapters.channel.webhook.secret": "ARCLITH_WEBHOOK_SECRET",
+        },
+    }
+    assert "arclith[fastapi,channel]>=0.23.0" in pyproject.read_text()
+    assert "a-secure-webhook-secret" not in config_path.read_text()
+
+
+def test_add_webhook_channel_generates_loadable_callback_config(
+    tmp_path: Path,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    add_adapter_cmd(
+        project_dir=project_dir,
+        capability_name="channel",
+        adapter="webhook",
+        adapter_params={
+            "response_mode": "callback",
+            "callback_url": "https://hooks.example.test/arclith",
+            "callback_allowed_host": "hooks.example.test",
+        },
+        yes=True,
+    )
+
+    from arclith import Arclith, WebhookCallbackSender
+
+    app = Arclith(project_dir / "config")
+    settings = app.config.adapters.channel.webhook
+
+    assert settings is not None
+    assert settings.response_mode == "callback"
+    assert settings.callback_url == "https://hooks.example.test/arclith"
+    assert isinstance(app.channel_sender("webhook"), WebhookCallbackSender)
+
+
+def test_add_slack_channel_generates_safe_loadable_config(tmp_path: Path) -> None:
+    project_dir = _minimal_project(tmp_path)
+    pyproject = project_dir / "pyproject.toml"
+    pyproject.write_text(
+        '[project]\ndependencies = ["arclith[fastapi]>=0.23.0"]\n',
+        encoding="utf-8",
+    )
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="channel",
+            adapter="slack",
+            adapter_params={
+                "path": "/integrations/slack/events",
+                "workspace_id": "T123ABC456",
+                "signature_tolerance_seconds": "120",
+                "event_ttl_seconds": "7200",
+                "max_payload_bytes": "65536",
+                "request_timeout_seconds": "2.5",
+            },
+            yes=True,
+        )
+
+    from arclith import Arclith
+
+    config_path = project_dir / "config" / "adapters" / "bidirectional" / "slack.yaml"
+    config = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+    app = Arclith(project_dir / "config")
+    secrets = yaml.safe_load(
+        (project_dir / "config" / "secrets.yaml").read_text(encoding="utf-8")
+    )
+
+    assert config["path"] == "/integrations/slack/events"
+    assert config["signing_secret"] is None
+    assert config["bot_token"] is None
+    assert config["workspace_id"] == "T123ABC456"
+    assert config["allowed_channel_ids"] == []
+    assert config["signature_tolerance_seconds"] == 120
+    assert config["event_ttl_seconds"] == 7200
+    assert config["max_payload_bytes"] == 65536
+    assert config["request_timeout_seconds"] == 2.5
+    assert app.config.adapters.channel.configured_adapters() == ("slack",)
+    assert secrets == {
+        "resolver": "env",
+        "mappings": {
+            "adapters.channel.slack.signing_secret": ("ARCLITH_SLACK_SIGNING_SECRET"),
+            "adapters.channel.slack.bot_token": "ARCLITH_SLACK_BOT_TOKEN",
+        },
+    }
+    assert "arclith[fastapi,channel]>=0.23.0" in pyproject.read_text()
+    assert "xoxb-" not in config_path.read_text()
+
+
 def test_add_keycloak_auth_adapter_generates_loadable_inbound_config(
     tmp_path: Path,
 ) -> None:
@@ -1701,7 +1860,7 @@ def test_add_langgraph_persistence_enriches_config_and_dependency_without_overwr
     (project_dir / "pyproject.toml").write_text(
         """[project]
 name = "demo-service"
-dependencies = ["arclith[fastapi,mcp]>=0.22.0"]
+dependencies = ["arclith[fastapi,mcp]>=0.23.0"]
 """,
         encoding="utf-8",
     )
@@ -1753,7 +1912,7 @@ dependencies = ["arclith[fastapi,mcp]>=0.22.0"]
     )
     pyproject = (project_dir / "pyproject.toml").read_text(encoding="utf-8")
     assert (
-        "arclith[fastapi,mcp,langgraph,langgraph-persistence-mongodb]>=0.22.0"
+        "arclith[fastapi,mcp,langgraph,langgraph-persistence-mongodb]>=0.23.0"
         in pyproject
     )
 
@@ -1775,7 +1934,7 @@ def test_add_langgraph_persistence_requires_agent_capability(
 ) -> None:
     project_dir = _minimal_project(tmp_path)
     (project_dir / "pyproject.toml").write_text(
-        '[project]\ndependencies = ["arclith>=0.22.0"]\n', encoding="utf-8"
+        '[project]\ndependencies = ["arclith>=0.23.0"]\n', encoding="utf-8"
     )
 
     with pytest.raises(typer.Exit):

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_capabilities.py

@@ -49,6 +49,80 @@ def test_repository_capability_catalog_declares_standard_adapters() -> None:
     ]
 
 
+def test_repository_adapter_facets_have_a_stable_serializable_shape() -> None:
+    capability = get_capability("repository")
+    assert capability is not None
+
+    expected_facets = {
+        "memory": (
+            "memory",
+            "in_process",
+            False,
+            False,
+            "none",
+            "flexible",
+        ),
+        "mongodb": (
+            "document",
+            "server",
+            True,
+            True,
+            "limited",
+            "flexible",
+        ),
+        "duckdb": (
+            "embedded_analytics",
+            "file",
+            False,
+            False,
+            "limited",
+            "structured_tables",
+        ),
+        "mariadb": (
+            "relational_json",
+            "server",
+            True,
+            True,
+            "strong",
+            "json_table",
+        ),
+        "postgresql": (
+            "relational_json",
+            "server",
+            True,
+            True,
+            "strong",
+            "json_table",
+        ),
+    }
+
+    for adapter in capability.adapters:
+        assert adapter.facets is not None
+        payload = adapter.facets.to_dict()
+        assert set(payload) == {
+            "storage_model",
+            "runtime",
+            "production_ready",
+            "multi_process",
+            "transactions",
+            "schema_strategy",
+            "recommended_for",
+            "limits",
+        }
+        assert (
+            payload["storage_model"],
+            payload["runtime"],
+            payload["production_ready"],
+            payload["multi_process"],
+            payload["transactions"],
+            payload["schema_strategy"],
+        ) == expected_facets[adapter.name]
+        assert payload["recommended_for"]
+        assert all(isinstance(value, str) for value in payload["recommended_for"])
+        assert payload["limits"]
+        assert all(isinstance(value, str) for value in payload["limits"])
+
+
 def test_cache_capability_catalog_declares_memory_adapter() -> None:
     capability = get_capability("cache")
 
@@ -317,6 +391,69 @@ def test_command_bus_capability_catalog_declares_rabbitmq() -> None:
     ]
 
 
+def test_channel_capability_catalog_declares_supported_adapters() -> None:
+    capability = get_capability("channel")
+
+    assert capability is not None
+    assert capability.layer == "bidirectional"
+    assert capability.activation_config_key is None
+    assert capability.adapter_names() == ("memory", "webhook", "slack")
+    memory = capability.get_adapter("memory")
+    assert memory is not None
+    assert memory.layer == "bidirectional"
+    assert memory.config_path == "config/adapters/bidirectional/memory.yaml"
+    assert memory.dependency_extra is None
+    assert memory.entity_scoped is False
+    assert memory.parameters == ()
+    webhook = capability.get_adapter("webhook")
+    assert webhook is not None
+    assert webhook.layer == "bidirectional"
+    assert webhook.config_path == "config/adapters/bidirectional/webhook.yaml"
+    assert webhook.dependency_extra == "channel"
+    assert webhook.entity_scoped is False
+    assert [parameter.name for parameter in webhook.parameters] == [
+        "path",
+        "signature_header",
+        "timestamp_header",
+        "signature_tolerance_seconds",
+        "idempotency_header",
+        "event_ttl_seconds",
+        "max_payload_bytes",
+        "response_mode",
+        "callback_url",
+        "callback_allowed_host",
+        "callback_timeout_seconds",
+    ]
+    assert [mapping.field_path for mapping in webhook.secret_mappings] == [
+        "adapters.channel.webhook.secret"
+    ]
+    assert [mapping.secret_key for mapping in webhook.secret_mappings] == [
+        "ARCLITH_WEBHOOK_SECRET"
+    ]
+    slack = capability.get_adapter("slack")
+    assert slack is not None
+    assert slack.layer == "bidirectional"
+    assert slack.config_path == "config/adapters/bidirectional/slack.yaml"
+    assert slack.dependency_extra == "channel"
+    assert slack.entity_scoped is False
+    assert [parameter.name for parameter in slack.parameters] == [
+        "path",
+        "workspace_id",
+        "signature_tolerance_seconds",
+        "event_ttl_seconds",
+        "max_payload_bytes",
+        "request_timeout_seconds",
+    ]
+    assert [mapping.field_path for mapping in slack.secret_mappings] == [
+        "adapters.channel.slack.signing_secret",
+        "adapters.channel.slack.bot_token",
+    ]
+    assert [mapping.secret_key for mapping in slack.secret_mappings] == [
+        "ARCLITH_SLACK_SIGNING_SECRET",
+        "ARCLITH_SLACK_BOT_TOKEN",
+    ]
+
+
 def test_runtime_capability_catalog_declares_docker_image() -> None:
     capability = get_capability("runtime")
 
@@ -704,6 +841,22 @@ def test_capabilities_command_outputs_json_catalog() -> None:
         "postgresql",
     ]
     assert repository["adapters"][0]["entity_scoped"] is True
+    assert repository["adapters"][0]["facets"] == {
+        "storage_model": "memory",
+        "runtime": "in_process",
+        "production_ready": False,
+        "multi_process": False,
+        "transactions": "none",
+        "schema_strategy": "flexible",
+        "recommended_for": [
+            "tests unitaires",
+            "développement et smoke dans un seul processus",
+        ],
+        "limits": [
+            "données perdues à l'arrêt",
+            "état non partagé entre processus",
+        ],
+    }
     duckdb = repository["adapters"][2]
     assert duckdb["name"] == "duckdb"
     assert duckdb["config_path"] == "config/adapters/outbound/duckdb.yaml"
@@ -730,6 +883,7 @@ def test_capabilities_command_outputs_json_catalog() -> None:
     filesystem = storage["adapters"][0]
     assert filesystem["config_path"] == "config/adapters/outbound/storage.yaml"
     assert filesystem["entity_scoped"] is False
+    assert filesystem["facets"] is None
     assert [parameter["name"] for parameter in filesystem["parameters"]] == [
         "root_path",
         "prefix",
@@ -888,6 +1042,26 @@ def test_capabilities_command_outputs_json_catalog() -> None:
         "dead_letter_exchange",
         "dead_letter_routing_key",
     ]
+    channel = payload_by_name["channel"]
+    assert channel["layer"] == "bidirectional"
+    assert [adapter["name"] for adapter in channel["adapters"]] == [
+        "memory",
+        "webhook",
+        "slack",
+    ]
+    memory_channel = channel["adapters"][0]
+    assert memory_channel["config_path"] == (
+        "config/adapters/bidirectional/memory.yaml"
+    )
+    assert memory_channel["dependency_extra"] is None
+    webhook_channel = channel["adapters"][1]
+    assert webhook_channel["config_path"] == (
+        "config/adapters/bidirectional/webhook.yaml"
+    )
+    assert webhook_channel["dependency_extra"] == "channel"
+    slack_channel = channel["adapters"][2]
+    assert slack_channel["config_path"] == ("config/adapters/bidirectional/slack.yaml")
+    assert slack_channel["dependency_extra"] == "channel"
     runtime = payload_by_name["runtime"]
     assert runtime["layer"] == "runtime"
     assert [adapter["name"] for adapter in runtime["adapters"]] == ["docker-image"]

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_core_scaffold.py

@@ -52,7 +52,7 @@ def test_init_project_creates_minimal_src_layout_without_entity(tmp_path: Path)
         "observability:\n"
         "  enabled: []\n"
     )
-    assert "arclith[fastapi,mcp]>=0.22.0" in (generated / "pyproject.toml").read_text(encoding="utf-8")
+    assert "arclith[fastapi,mcp]>=0.23.0" in (generated / "pyproject.toml").read_text(encoding="utf-8")
     assert (package_root / "domain" / "models" / "__init__.py").exists()
     assert (package_root / "domain" / "ports" / "inbound" / "__init__.py").exists()
     assert (package_root / "domain" / "ports" / "outbound" / "__init__.py").exists()

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_embedding_capability.py

@@ -15,7 +15,7 @@ def _minimal_project(tmp_path: Path) -> Path:
     )
     (project_dir / "pyproject.toml").write_text(
         '[project]\nname = "demo-service"\nversion = "0.1.0"\n'
-        'dependencies = ["arclith>=0.22.0"]\n',
+        'dependencies = ["arclith>=0.23.0"]\n',
         encoding="utf-8",
     )
     return project_dir
@@ -197,7 +197,7 @@ def test_add_openai_compatible_embedding_generates_loadable_config_idempotently(
     assert app.config.adapters.embedding is not None
     assert app.config.adapters.embedding.model_name == "nomic-embed-text"
     assert isinstance(app.embedding(), OpenAICompatibleEmbeddingAdapter)
-    assert "arclith[embedding]>=0.22.0" in (project_dir / "pyproject.toml").read_text(
+    assert "arclith[embedding]>=0.23.0" in (project_dir / "pyproject.toml").read_text(
         encoding="utf-8"
     )
 
@@ -244,7 +244,7 @@ def test_add_openai_embedding_generates_safe_loadable_config_idempotently(
     assert env_text == "EXISTING=value\n"
     assert "sk-" not in config_text + secrets_text + env_text
     assert ".env" in (project_dir / ".gitignore").read_text(encoding="utf-8")
-    assert "arclith[embedding]>=0.22.0" in (project_dir / "pyproject.toml").read_text(
+    assert "arclith[embedding]>=0.23.0" in (project_dir / "pyproject.toml").read_text(
         encoding="utf-8"
     )
 

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_project_paths.py

@@ -14,6 +14,7 @@ def test_detect_project_paths_uses_src_package(tmp_path: Path):
     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.adapters_bidirectional == package_root / "adapters" / "bidirectional"
     assert paths.containers == package_root / "infrastructure" / "containers"
     assert paths.import_path("domain", "models", "recipe") == "my_service.domain.models.recipe"
 

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/tests/test_vector_store_capability.py

@@ -15,7 +15,7 @@ def _minimal_project(tmp_path: Path) -> Path:
     )
     (project_dir / "pyproject.toml").write_text(
         '[project]\nname = "demo-service"\nversion = "0.1.0"\n'
-        'dependencies = ["arclith>=0.22.0"]\n',
+        'dependencies = ["arclith>=0.23.0"]\n',
         encoding="utf-8",
     )
     return project_dir

{arclith_cli-0.19.0 → arclith_cli-0.20.0}/uv.lock

@@ -46,7 +46,7 @@ wheels = [
 
 [[package]]
 name = "arclith"
-version = "0.22.0"
+version = "0.23.0"
 source = { editable = "../" }
 dependencies = [
     { name = "fastapi" },
@@ -83,6 +83,7 @@ requires-dist = [
     { name = "google-cloud-storage", marker = "extra == 'gcs'", specifier = ">=3.3.0,<4.0.0" },
     { name = "httpx", marker = "extra == 'all'", specifier = ">=0.27.0" },
     { name = "httpx", marker = "extra == 'auth'", specifier = ">=0.27.0" },
+    { name = "httpx", marker = "extra == 'channel'", specifier = ">=0.27.0" },
     { name = "httpx", marker = "extra == 'embedding'", specifier = ">=0.27.0" },
     { name = "hvac", marker = "extra == 'all'", specifier = "==2.3.0" },
     { name = "hvac", marker = "extra == 'vault'", specifier = "==2.3.0" },
@@ -143,7 +144,7 @@ requires-dist = [
     { name = "uvicorn", marker = "extra == 'fastapi'", specifier = "==0.41.0" },
     { name = "uvicorn", marker = "extra == 'langgraph-runtime'", specifier = "==0.41.0" },
 ]
-provides-extras = ["mongodb", "duckdb", "mariadb", "postgresql", "fastapi", "mcp", "vault", "cache", "auth", "embedding", "rabbitmq", "langgraph", "langgraph-runtime", "langgraph-persistence-sqlite", "langgraph-persistence-postgresql", "langgraph-persistence-mongodb", "langgraph-persistence-redis", "langsmith", "opentelemetry", "all", "azure-blob", "s3", "gcs", "qdrant"]
+provides-extras = ["mongodb", "duckdb", "mariadb", "postgresql", "fastapi", "mcp", "vault", "cache", "auth", "embedding", "channel", "rabbitmq", "langgraph", "langgraph-runtime", "langgraph-persistence-sqlite", "langgraph-persistence-postgresql", "langgraph-persistence-mongodb", "langgraph-persistence-redis", "langsmith", "opentelemetry", "all", "azure-blob", "s3", "gcs", "qdrant"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -165,7 +166,7 @@ docs = [
 
 [[package]]
 name = "arclith-cli"
-version = "0.19.0"
+version = "0.20.0"
 source = { editable = "." }
 dependencies = [
     { name = "arclith" },

arclith_cli-0.19.0/arclith_cli/__init__.py

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