arclith-cli 0.13.0__tar.gz → 0.15.0__tar.gz

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arclith-cli
-Version: 0.13.0
+Version: 0.15.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.16.0
+Requires-Dist: arclith>=0.18.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/README.md

@@ -141,7 +141,7 @@ arclith-cli add-adapter --adapter mariadb --entity Recipe --param database=my_re
 arclith-cli add-adapter --capability api --adapter fastapi --param port=8080 --yes
 arclith-cli add-adapter --capability mcp --adapter fastmcp --param port=8081 --yes
 arclith-cli add-adapter --capability llm --adapter lmstudio --param model_name=qwen/qwen3.5-9b --yes
-arclith-cli add-adapter --capability agent --adapter langgraph --param graph_name=recipe_agent --yes
+arclith-cli add-adapter --capability agent --adapter langgraph --param graph_name=recipe_agent --param stream_mode=updates,custom --yes
 arclith-cli add-adapter --capability observability --adapter langsmith
 arclith-cli add-adapter --capability observability --adapter opentelemetry --param service_name=my_recipe_service --yes
 arclith-cli add-adapter --capability runtime --adapter docker-image --yes
@@ -166,7 +166,7 @@ arclith-cli add-adapter --capability repository --adapter memory --entity Recipe
    - `lmstudio` → `model_name`, `base_url`, `api_key`
    - `openai` → `model_name`, `base_url`, `OPENAI_API_KEY`
    - `anthropic` → `model_name`, `ANTHROPIC_API_KEY`
-   - `langgraph` → `graph_name`
+   - `langgraph` → `graph_name`, `stream_mode`
    - `langsmith` → `tracing`, `project`, `endpoint`, `LANGSMITH_API_KEY`
    - `opentelemetry` → `service_name`, `endpoint`, `traces_endpoint`, `metrics_endpoint`, `protocol`, `traces`, `metrics`, `instrument_fastapi`
    - `command-bus/rabbitmq` → `url`, `exchange`, `exchange_type`, `queue`, `routing_key`, `prefetch`, `consumer_name`, `concurrency`, `publisher_confirms`, `durable`, `retry_enabled`, `retry_requeue`, `dead_letter_exchange`, `dead_letter_routing_key`
@@ -240,7 +240,9 @@ l'environnement, un fichier local de secrets ou Vault selon le resolver choisi.
 L'adapter `agent/langgraph` génère `langgraph.json`, `config/adapters/inbound/langgraph.yaml` et
 `src/<package>/adapters/inbound/langgraph/agent.py`. Le projet ne modifie ensuite que ce fichier pour
 son agent. Comme `fastapi` et `fastmcp`, LangGraph est configuré par son nom produit dans
-`AppConfig.langgraph`, sans `adapters.agent`. L'adapter `observability/langsmith` génère
+`AppConfig.langgraph`, sans `adapters.agent`. `stream_mode` vaut `updates` par défaut et accepte une
+liste CSV comme `updates,custom` pour exposer les sorties de nodes et les événements
+`get_stream_writer()`. L'adapter `observability/langsmith` génère
 `config/adapters/outbound/langsmith.yaml`, l'ajoute à `observability.enabled`, met
 à jour `.env` et ajoute `.env` au `.gitignore` si besoin. LangSmith Studio devient l'endroit standard
 pour tester les agents. Une `LANGSMITH_API_KEY` déjà présente est conservée si aucune nouvelle valeur

arclith_cli-0.15.0/arclith_cli/__init__.py

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

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/arclith_cli/adapter_templates.py

@@ -66,6 +66,20 @@ class MariaDB{pascal}Repository(MariaDBRepository[{pascal}], {pascal}Repository)
 
     # TODO: add custom query methods here
 """,
+    "postgresql": """\
+from arclith.adapters.outbound.postgresql.config import PostgreSQLConfig
+from arclith.adapters.outbound.postgresql.repository import PostgreSQLRepository
+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 PostgreSQL{pascal}Repository(PostgreSQLRepository[{pascal}], {pascal}Repository):
+    def __init__(self, config: PostgreSQLConfig, logger: Logger) -> None:
+        super().__init__(config, {pascal}, logger)
+
+    # TODO: add custom query methods here
+""",
 }
 
 # ── repository.py re-export template ─────────────────────────────────────────
@@ -90,6 +104,11 @@ __all__ = ["DuckDB{pascal}Repository"]
 from {adapters_import}.outbound.mariadb.repositories.{snake}_repository import MariaDB{pascal}Repository
 
 __all__ = ["MariaDB{pascal}Repository"]
+""",
+    "postgresql": """\
+from {adapters_import}.outbound.postgresql.repositories.{snake}_repository import PostgreSQL{pascal}Repository
+
+__all__ = ["PostgreSQL{pascal}Repository"]
 """,
 }
 
@@ -152,6 +171,29 @@ def _build_mariadb(cfg: AppConfig, _entity_class: type[{pascal}], log: Logger) -
         log,
     )
 
+""",
+    "postgresql": """\
+def _build_postgresql(cfg: AppConfig, _entity_class: type[{pascal}], log: Logger) -> {pascal}Repository:
+    from {adapters_import}.outbound.postgresql.repository import PostgreSQL{pascal}Repository
+    from arclith.adapters.outbound.postgresql.config import PostgreSQLConfig
+    postgresql = cfg.adapters.postgresql
+    if postgresql is None:
+        raise ValueError("PostgreSQL settings are required when repository=postgresql")
+    return PostgreSQL{pascal}Repository(
+        PostgreSQLConfig(
+            url=postgresql.url,
+            host=postgresql.host,
+            port=postgresql.port,
+            database=postgresql.database,
+            user=postgresql.user,
+            password=postgresql.password,
+            schema=postgresql.schema_name,
+            driver=postgresql.driver,
+            table_prefix=postgresql.table_prefix,
+        ),
+        log,
+    )
+
 """,
 }
 
@@ -169,7 +211,9 @@ def build_{snake}_service(arclith: Arclith) -> tuple[{pascal}Service, Logger]:
 """
 
 
-def render_container(pascal: str, snake: str, installed_adapters: list[str], import_vars: dict[str, str]) -> str:
+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))
@@ -182,9 +226,7 @@ def render_container(pascal: str, snake: str, installed_adapters: list[str], imp
         if a in _CONTAINER_FACTORY
     )
     registrations = "\n".join(
-        f"    .register(\"{a}\", _build_{a})"
-        for a in adapters
-        if a in _CONTAINER_FACTORY
+        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

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/arclith_cli/add_adapter.py

@@ -686,11 +686,19 @@ def _file_template_vars(
         "package_path": package_path,
         "langgraph_entrypoint": langgraph_entrypoint,
         "graph_name": graph_name,
+        "stream_mode_yaml": _langgraph_stream_mode_yaml(str(params.get("stream_mode") or "updates")),
         "secret_template_yaml": _secret_template_yaml(str(params.get("field_path") or "")),
         "secret_chain_yaml": _secret_chain_yaml(str(params.get("resolvers") or "")),
     }
 
 
+def _langgraph_stream_mode_yaml(stream_mode: str) -> str:
+    values = _split_csv_values(stream_mode)
+    if len(values) == 1:
+        return f'"{values[0]}"'
+    return yaml.safe_dump(values, default_flow_style=True, sort_keys=False).strip()
+
+
 def _secret_template_yaml(field_path: str) -> str:
     keys = [key for key in field_path.split(".") if key]
     if not keys:

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/arclith_cli/capabilities.py

@@ -108,10 +108,16 @@ class AdapterSpec:
             "layer": self.layer,
             "description": self.description,
             "config_path": self.config_path,
-            "merge_config_templates": [file_template.to_dict() for file_template in self.merge_config_templates],
+            "merge_config_templates": [
+                file_template.to_dict() for file_template in self.merge_config_templates
+            ],
             "env_path": self.env_path,
-            "file_templates": [file_template.to_dict() for file_template in self.file_templates],
-            "secret_mappings": [secret_mapping.to_dict() for secret_mapping in self.secret_mappings],
+            "file_templates": [
+                file_template.to_dict() for file_template in self.file_templates
+            ],
+            "secret_mappings": [
+                secret_mapping.to_dict() for secret_mapping in self.secret_mappings
+            ],
             "secret_resolver": self.secret_resolver,
             "secret_config_template": bool(self.secret_config_template),
             "gitignore_entries": list(self.gitignore_entries),
@@ -284,6 +290,305 @@ multitenant: false
                 ),
             ),
         ),
+        AdapterSpec(
+            name="postgresql",
+            capability="repository",
+            layer="outbound",
+            description="Repository PostgreSQL async optionnel, pilote par SQLAlchemy et asyncpg, avec payload JSONB generique.",
+            config_path="config/adapters/outbound/postgresql.yaml",
+            config_template="""\
+url: null   # à mapper via config/secrets.yaml ou resolver env/vault si vous fournissez une URL complète
+host: {host}
+port: {port}
+database: {database}
+user: {user}
+password: null   # à mapper via config/secrets.yaml ou resolver env/vault
+schema: {schema}
+driver: {driver}
+table_prefix: "{table_prefix}"
+multitenant: {multitenant}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.postgresql.url",
+                    secret_key="POSTGRESQL_URL",
+                ),
+                SecretMappingSpec(
+                    field_path="adapters.postgresql.password",
+                    secret_key="POSTGRESQL_PASSWORD",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="host",
+                    kind="string",
+                    prompt="host",
+                    default="127.0.0.1",
+                ),
+                ParameterSpec(
+                    name="port",
+                    kind="string",
+                    prompt="port",
+                    default="5432",
+                ),
+                ParameterSpec(
+                    name="database",
+                    kind="string",
+                    prompt="database",
+                    default_from_project_name=True,
+                ),
+                ParameterSpec(
+                    name="user",
+                    kind="string",
+                    prompt="user",
+                    default="app",
+                ),
+                ParameterSpec(
+                    name="schema",
+                    kind="string",
+                    prompt="schema",
+                    default="public",
+                ),
+                ParameterSpec(
+                    name="driver",
+                    kind="string",
+                    prompt="driver",
+                    default="asyncpg",
+                ),
+                ParameterSpec(
+                    name="table_prefix",
+                    kind="string",
+                    prompt="table_prefix",
+                    default="",
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="multitenant",
+                    default=False,
+                ),
+            ),
+        ),
+    ),
+)
+
+STORAGE_CAPABILITY = CapabilitySpec(
+    name="storage",
+    layer="outbound",
+    description="Stockage de fichiers et blobs derrière un port FileStoragePort.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="filesystem",
+            capability="storage",
+            layer="outbound",
+            description="Stockage fichier local, typiquement monté dans Docker via un volume.",
+            config_path="config/adapters/outbound/storage.yaml",
+            config_template="""\
+adapter: filesystem
+root_path: "{root_path}"
+prefix: "{prefix}"
+create_root: {create_root}
+multitenant: {multitenant}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="root_path",
+                    kind="string",
+                    prompt="Chemin conteneur du dossier de fichiers",
+                    default="/data/files",
+                ),
+                ParameterSpec(
+                    name="prefix",
+                    kind="string",
+                    prompt="Préfixe d'objets",
+                    default="",
+                ),
+                ParameterSpec(
+                    name="create_root",
+                    kind="boolean",
+                    prompt="Créer le dossier racine au démarrage",
+                    default=True,
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Résoudre le stockage par tenant",
+                    default=False,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="s3",
+            capability="storage",
+            layer="outbound",
+            description="Stockage objet AWS S3 compatible MinIO via endpoint custom.",
+            config_path="config/adapters/outbound/storage.yaml",
+            config_template="""\
+adapter: s3
+# Credentials: chaîne AWS par défaut, variables d'environnement, rôle IAM ou TenantContext.
+bucket_name: "{bucket_name}"
+prefix: "{prefix}"
+region_name: "{region_name}"
+endpoint_url: {endpoint_url}
+force_path_style: {force_path_style}
+multitenant: {multitenant}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="bucket_name",
+                    kind="string",
+                    prompt="Bucket S3",
+                    default="my-bucket",
+                ),
+                ParameterSpec(
+                    name="prefix",
+                    kind="string",
+                    prompt="Préfixe d'objets",
+                    default="",
+                ),
+                ParameterSpec(
+                    name="region_name",
+                    kind="string",
+                    prompt="Région AWS",
+                    default="eu-west-3",
+                ),
+                ParameterSpec(
+                    name="endpoint_url",
+                    kind="string",
+                    prompt="Endpoint S3 custom ou null",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="force_path_style",
+                    kind="boolean",
+                    prompt="Forcer le path-style S3",
+                    default=False,
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Résoudre le stockage par tenant",
+                    default=False,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="azure-blob",
+            capability="storage",
+            layer="outbound",
+            description="Stockage objet Azure Blob Storage.",
+            config_path="config/adapters/outbound/storage.yaml",
+            config_template="""\
+adapter: azure-blob
+account_url: "{account_url}"
+container_name: "{container_name}"
+prefix: "{prefix}"
+connection_string: null
+account_key: null
+sas_token: null
+use_default_credential: {use_default_credential}
+multitenant: {multitenant}
+# Credentials: mappez connection_string, account_key ou sas_token via
+# config/secrets.yaml, Vault, ou TenantContext. use_default_credential=true
+# délègue à DefaultAzureCredential du SDK Azure.
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.storage.connection_string",
+                    secret_key="AZURE_STORAGE_CONNECTION_STRING",
+                ),
+                SecretMappingSpec(
+                    field_path="adapters.storage.account_key",
+                    secret_key="AZURE_STORAGE_ACCOUNT_KEY",
+                ),
+                SecretMappingSpec(
+                    field_path="adapters.storage.sas_token",
+                    secret_key="AZURE_STORAGE_SAS_TOKEN",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="account_url",
+                    kind="string",
+                    prompt="URL du compte Azure Blob",
+                    default="https://<account>.blob.core.windows.net",
+                ),
+                ParameterSpec(
+                    name="container_name",
+                    kind="string",
+                    prompt="Container Azure Blob",
+                    default="my-container",
+                ),
+                ParameterSpec(
+                    name="prefix",
+                    kind="string",
+                    prompt="Préfixe d'objets",
+                    default="",
+                ),
+                ParameterSpec(
+                    name="use_default_credential",
+                    kind="boolean",
+                    prompt="Utiliser DefaultAzureCredential",
+                    default=False,
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Résoudre le stockage par tenant",
+                    default=False,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="gcs",
+            capability="storage",
+            layer="outbound",
+            description="Stockage objet Google Cloud Storage.",
+            config_path="config/adapters/outbound/storage.yaml",
+            config_template="""\
+adapter: gcs
+bucket_name: "{bucket_name}"
+prefix: "{prefix}"
+project_id: {project_id}
+credentials_path: null
+credentials_json: null
+credentials_json_b64: null
+multitenant: {multitenant}
+# Credentials: use ADC/GOOGLE_APPLICATION_CREDENTIALS, config/secrets.yaml,
+# Vault, or TenantContext. Never commit service account JSON.
+""",
+            parameters=(
+                ParameterSpec(
+                    name="bucket_name",
+                    kind="string",
+                    prompt="Bucket Google Cloud Storage",
+                    default="my-bucket",
+                ),
+                ParameterSpec(
+                    name="prefix",
+                    kind="string",
+                    prompt="Préfixe d'objets",
+                    default="",
+                ),
+                ParameterSpec(
+                    name="project_id",
+                    kind="string",
+                    prompt="Project ID GCP ou null",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Résoudre le stockage par tenant",
+                    default=False,
+                ),
+            ),
+            entity_scoped=False,
+        ),
     ),
 )
 
@@ -1263,6 +1568,7 @@ name: "{graph_name}"
 graph: "{graph_name}"
 entrypoint: "{langgraph_entrypoint}"
 env: ".env"
+stream_mode: {stream_mode_yaml}
 """,
             file_templates=(
                 FileTemplateSpec(
@@ -1287,6 +1593,7 @@ env: ".env"
 from typing import Any, TypedDict
 
 from arclith import Arclith
+from langgraph.config import get_stream_writer
 from langgraph.graph import END, START
 
 
@@ -1300,6 +1607,8 @@ arclith = Arclith("config")
 # Template minimal volontaire: remplacer AgentState, run_agent et les edges par
 # l'état, les noeuds et les transitions propres au projet.
 async def run_agent(state: AgentState) -> AgentState:
+    writer = get_stream_writer()
+    writer({{"kind": "progress", "stage": "agent.started", "message": "Agent node started."}})
     return state
 
 
@@ -1320,6 +1629,22 @@ agent = arclith.langgraph(AgentState, register_agent, name="{graph_name}")
                     prompt="Nom du graphe LangGraph",
                     default="agent",
                 ),
+                ParameterSpec(
+                    name="stream_mode",
+                    kind="string",
+                    prompt="Mode(s) de streaming LangGraph",
+                    default="updates",
+                    choices=(
+                        "values",
+                        "updates",
+                        "custom",
+                        "messages",
+                        "checkpoints",
+                        "tasks",
+                        "debug",
+                    ),
+                    csv_choices=True,
+                ),
             ),
             entity_scoped=False,
         ),
@@ -1478,6 +1803,7 @@ OTEL_EXPORTER_OTLP_HEADERS={headers}
 
 CAPABILITY_CATALOG = (
     REPOSITORY_CAPABILITY,
+    STORAGE_CAPABILITY,
     CACHE_CAPABILITY,
     LOGGER_CAPABILITY,
     SECRETS_CAPABILITY,

{arclith_cli-0.13.0 → arclith_cli-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arclith-cli"
-version = "0.13.0"
+version = "0.15.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.16.0",
+    "arclith>=0.18.0",
 ]
 
 [tool.uv.sources]

{arclith_cli-0.13.0 → arclith_cli-0.15.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.16.0"
+MIN_ARCLITH_VERSION="0.18.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