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

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

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

arclith_cli-0.19.0/arclith_cli/__init__.py

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

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

@@ -24,7 +24,11 @@ from arclith_cli.catalogs.core import (
     SECRETS_CAPABILITY,
 )
 from arclith_cli.catalogs.observability import OBSERVABILITY_CAPABILITY
-from arclith_cli.catalogs.persistence import REPOSITORY_CAPABILITY, STORAGE_CAPABILITY
+from arclith_cli.catalogs.persistence import (
+    REPOSITORY_CAPABILITY,
+    STORAGE_CAPABILITY,
+    VECTOR_STORE_CAPABILITY,
+)
 from arclith_cli.catalogs.security import (
     AUTH_CAPABILITY,
     LICENSE_CAPABILITY,
@@ -68,6 +72,7 @@ __all__ = [
     "STORAGE_CAPABILITY",
     "SecretMappingSpec",
     "TENANT_CAPABILITY",
+    "VECTOR_STORE_CAPABILITY",
     "capability_catalog_as_dict",
     "capability_names",
     "get_capability",
@@ -77,6 +82,7 @@ __all__ = [
 CAPABILITY_CATALOG = (
     REPOSITORY_CAPABILITY,
     STORAGE_CAPABILITY,
+    VECTOR_STORE_CAPABILITY,
     CACHE_CAPABILITY,
     LOGGER_CAPABILITY,
     SECRETS_CAPABILITY,

{arclith_cli-0.18.0 → arclith_cli-0.19.0}/arclith_cli/catalogs/ai.py

@@ -260,6 +260,95 @@ multitenant: {multitenant}
             dependency_extra="embedding",
             entity_scoped=False,
         ),
+        AdapterSpec(
+            name="openai",
+            capability="embedding",
+            layer="outbound",
+            description="Embeddings via l'API OpenAI officielle et un secret externe.",
+            config_path="config/adapters/outbound/embedding.yaml",
+            config_template="""\
+adapter: openai
+base_url: "{base_url}"
+api_key: null
+model_name: "{model_name}"
+dimensions: {dimensions}
+batch_size: {batch_size}
+timeout: {timeout}
+encoding_format: {encoding_format}
+normalize: {normalize}
+multitenant: {multitenant}
+""",
+            env_path=".env",
+            env_template="""\
+OPENAI_API_KEY={api_key}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.embedding.api_key",
+                    secret_key="OPENAI_API_KEY",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="base_url",
+                    kind="string",
+                    prompt="Endpoint officiel OpenAI avec préfixe API",
+                    default="https://api.openai.com/v1",
+                ),
+                ParameterSpec(
+                    name="api_key",
+                    kind="string",
+                    prompt="OPENAI_API_KEY (laisser vide pour un secret externe)",
+                    default="",
+                    secret=True,
+                ),
+                ParameterSpec(
+                    name="model_name",
+                    kind="string",
+                    prompt="ID du modèle d'embedding OpenAI accessible au projet",
+                    default="remplacer-par-model-id-openai-embedding",
+                ),
+                ParameterSpec(
+                    name="dimensions",
+                    kind="string",
+                    prompt="Dimension optionnelle des vecteurs (null pour le défaut modèle)",
+                    default="null",
+                ),
+                ParameterSpec(
+                    name="batch_size",
+                    kind="string",
+                    prompt="Taille maximale des sous-batches",
+                    default="64",
+                ),
+                ParameterSpec(
+                    name="timeout",
+                    kind="string",
+                    prompt="Timeout HTTP en secondes",
+                    default="30.0",
+                ),
+                ParameterSpec(
+                    name="encoding_format",
+                    kind="string",
+                    prompt="Format des vecteurs retournés",
+                    default="float",
+                    choices=("float",),
+                ),
+                ParameterSpec(
+                    name="normalize",
+                    kind="boolean",
+                    prompt="Normaliser les vecteurs en norme L2",
+                    default=False,
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Réserver la résolution de contexte par tenant",
+                    default=False,
+                ),
+            ),
+            dependency_extra="embedding",
+            entity_scoped=False,
+        ),
     ),
 )
 

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

@@ -444,3 +444,132 @@ multitenant: {multitenant}
         ),
     ),
 )
+
+VECTOR_STORE_CAPABILITY = CapabilitySpec(
+    name="vector-store",
+    layer="outbound",
+    description="Indexation et recherche dense derrière un port provider-neutral.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="memory",
+            capability="vector-store",
+            layer="outbound",
+            description="Recherche exacte déterministe sans dépendance pour tests et POC.",
+            config_path="config/adapters/outbound/vector_store.yaml",
+            config_template="""\
+adapter: memory
+collection_name: "{collection_name}"
+vector_size: {vector_size}
+distance: {distance}
+multitenant: {multitenant}
+""",
+            parameters=(
+                ParameterSpec(
+                    name="collection_name",
+                    kind="string",
+                    prompt="Nom logique de la collection",
+                    default="default",
+                ),
+                ParameterSpec(
+                    name="vector_size",
+                    kind="string",
+                    prompt="Dimension obligatoire des vecteurs",
+                    default="1536",
+                ),
+                ParameterSpec(
+                    name="distance",
+                    kind="string",
+                    prompt="Métrique de similarité",
+                    default="cosine",
+                    choices=("cosine", "dot", "euclid"),
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Réserver la résolution de contexte par tenant",
+                    default=False,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="qdrant",
+            capability="vector-store",
+            layer="outbound",
+            description="Index vectoriel dense Qdrant via le client Python async officiel.",
+            config_path="config/adapters/outbound/vector_store.yaml",
+            config_template="""\
+adapter: qdrant
+url: "{url}"
+api_key: null
+collection_name: "{collection_name}"
+vector_size: {vector_size}
+distance: {distance}
+prefer_grpc: {prefer_grpc}
+timeout: {timeout}
+create_collection: {create_collection}
+multitenant: {multitenant}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.vector_store.api_key",
+                    secret_key="QDRANT_API_KEY",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="url",
+                    kind="string",
+                    prompt="Endpoint HTTP Qdrant sans credentials",
+                    default="http://localhost:6333",
+                ),
+                ParameterSpec(
+                    name="collection_name",
+                    kind="string",
+                    prompt="Nom de la collection Qdrant",
+                    default="default",
+                ),
+                ParameterSpec(
+                    name="vector_size",
+                    kind="string",
+                    prompt="Dimension obligatoire des vecteurs",
+                    default="1536",
+                ),
+                ParameterSpec(
+                    name="distance",
+                    kind="string",
+                    prompt="Métrique de similarité",
+                    default="cosine",
+                    choices=("cosine", "dot", "euclid"),
+                ),
+                ParameterSpec(
+                    name="prefer_grpc",
+                    kind="boolean",
+                    prompt="Préférer le transport gRPC",
+                    default=False,
+                ),
+                ParameterSpec(
+                    name="timeout",
+                    kind="string",
+                    prompt="Timeout client en secondes",
+                    default="5.0",
+                ),
+                ParameterSpec(
+                    name="create_collection",
+                    kind="boolean",
+                    prompt="Créer la collection si elle manque",
+                    default=True,
+                ),
+                ParameterSpec(
+                    name="multitenant",
+                    kind="boolean",
+                    prompt="Résoudre url, api_key et collection par tenant",
+                    default=False,
+                ),
+            ),
+            dependency_extra="qdrant",
+            entity_scoped=False,
+        ),
+    ),
+)

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

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

{arclith_cli-0.18.0 → arclith_cli-0.19.0}/arclith_cli/main.py

@@ -164,7 +164,7 @@ def add_adapter(
             "--capability",
             help=(
                 "Capacité cible: repository, cache, logger, secrets, api, mcp, probe, http, "
-                "command-bus, runtime, auth, tenant, license, llm, embedding, agent, "
+                "command-bus, runtime, auth, tenant, license, llm, embedding, vector-store, agent, "
                 "agent-persistence ou observability"
             ),
         ),

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

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

{arclith_cli-0.18.0 → arclith_cli-0.19.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.21.0"
+MIN_ARCLITH_VERSION="0.22.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.18.0 → arclith_cli-0.19.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.21.0"]\n',
+        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.22.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.21.0" in pyproject.read_text()
+    assert "arclith[fastapi,mcp,langsmith]>=0.22.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.21.0"]\n',
+        '[project]\ndependencies = ["arclith[fastapi,mcp]>=0.22.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.21.0" in pyproject.read_text()
+    assert "arclith[fastapi,mcp,opentelemetry]>=0.22.0" in pyproject.read_text()
 
 
 @pytest.mark.parametrize(
@@ -1701,7 +1701,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.21.0"]
+dependencies = ["arclith[fastapi,mcp]>=0.22.0"]
 """,
         encoding="utf-8",
     )
@@ -1753,7 +1753,7 @@ dependencies = ["arclith[fastapi,mcp]>=0.21.0"]
     )
     pyproject = (project_dir / "pyproject.toml").read_text(encoding="utf-8")
     assert (
-        "arclith[fastapi,mcp,langgraph,langgraph-persistence-mongodb]>=0.21.0"
+        "arclith[fastapi,mcp,langgraph,langgraph-persistence-mongodb]>=0.22.0"
         in pyproject
     )
 
@@ -1775,7 +1775,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.21.0"]\n', encoding="utf-8"
+        '[project]\ndependencies = ["arclith>=0.22.0"]\n', encoding="utf-8"
     )
 
     with pytest.raises(typer.Exit):

{arclith_cli-0.18.0 → arclith_cli-0.19.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.21.0" in (generated / "pyproject.toml").read_text(encoding="utf-8")
+    assert "arclith[fastapi,mcp]>=0.22.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.18.0 → arclith_cli-0.19.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.21.0"]\n',
+        'dependencies = ["arclith>=0.22.0"]\n',
         encoding="utf-8",
     )
     return project_dir
@@ -27,7 +27,11 @@ def test_embedding_capability_catalog_declares_deterministic_adapter() -> None:
     assert capability is not None
     assert capability.layer == "outbound"
     assert capability.activation_config_key is None
-    assert capability.adapter_names() == ("deterministic", "openai-compatible")
+    assert capability.adapter_names() == (
+        "deterministic",
+        "openai-compatible",
+        "openai",
+    )
     deterministic = capability.get_adapter("deterministic")
     assert deterministic is not None
     assert deterministic.entity_scoped is False
@@ -53,6 +57,29 @@ def test_embedding_capability_catalog_declares_deterministic_adapter() -> None:
         "normalize",
         "multitenant",
     ]
+    openai = capability.get_adapter("openai")
+    assert openai is not None
+    assert openai.entity_scoped is False
+    assert openai.dependency_extra == "embedding"
+    assert openai.secret_mappings[0].field_path == "adapters.embedding.api_key"
+    assert openai.secret_mappings[0].secret_key == "OPENAI_API_KEY"
+    assert [parameter.name for parameter in openai.parameters] == [
+        "base_url",
+        "api_key",
+        "model_name",
+        "dimensions",
+        "batch_size",
+        "timeout",
+        "encoding_format",
+        "normalize",
+        "multitenant",
+    ]
+    assert (
+        next(
+            parameter for parameter in openai.parameters if parameter.name == "api_key"
+        ).secret
+        is True
+    )
 
 
 def test_embedding_capability_is_exposed_in_json_catalog() -> None:
@@ -65,6 +92,20 @@ def test_embedding_capability_is_exposed_in_json_catalog() -> None:
     assert [adapter["name"] for adapter in embedding["adapters"]] == [
         "deterministic",
         "openai-compatible",
+        "openai",
+    ]
+    openai = embedding["adapters"][2]
+    api_key = next(
+        parameter
+        for parameter in openai["parameters"]
+        if parameter["name"] == "api_key"
+    )
+    assert api_key["secret"] is True
+    assert openai["secret_mappings"] == [
+        {
+            "field_path": "adapters.embedding.api_key",
+            "secret_key": "OPENAI_API_KEY",
+        }
     ]
 
 
@@ -156,6 +197,87 @@ 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.21.0" in (project_dir / "pyproject.toml").read_text(
+    assert "arclith[embedding]>=0.22.0" in (project_dir / "pyproject.toml").read_text(
         encoding="utf-8"
     )
+
+
+def test_add_openai_embedding_generates_safe_loadable_config_idempotently(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+    (project_dir / ".env").write_text("EXISTING=value\n", encoding="utf-8")
+    params = {
+        "model_name": "configured-embedding-model",
+        "dimensions": "1536",
+    }
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="embedding",
+            adapter="openai",
+            adapter_params=params,
+            yes=True,
+        )
+
+    config_path = project_dir / "config/adapters/outbound/embedding.yaml"
+    config_text = config_path.read_text(encoding="utf-8")
+    secrets_text = (project_dir / "config/secrets.yaml").read_text(encoding="utf-8")
+    env_text = (project_dir / ".env").read_text(encoding="utf-8")
+
+    assert config_text == (
+        "adapter: openai\n"
+        'base_url: "https://api.openai.com/v1"\n'
+        "api_key: null\n"
+        'model_name: "configured-embedding-model"\n'
+        "dimensions: 1536\n"
+        "batch_size: 64\n"
+        "timeout: 30.0\n"
+        "encoding_format: float\n"
+        "normalize: false\n"
+        "multitenant: false\n"
+    )
+    assert "adapters.embedding.api_key: OPENAI_API_KEY" in secrets_text
+    assert secrets_text.count("adapters.embedding.api_key") == 1
+    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(
+        encoding="utf-8"
+    )
+
+    monkeypatch.setenv("OPENAI_API_KEY", "test-key")
+    from arclith import Arclith
+    from arclith.adapters.outbound.openai import OpenAIEmbeddingAdapter
+
+    app = Arclith(project_dir / "config")
+
+    assert app.config.adapters.embedding is not None
+    assert app.config.adapters.embedding.api_key == "test-key"
+    assert type(app.embedding()) is OpenAIEmbeddingAdapter
+
+
+def test_add_openai_embedding_omits_fake_key_and_keeps_dimensions_optional(
+    tmp_path: Path,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+
+    add_adapter_cmd(
+        project_dir=project_dir,
+        capability_name="embedding",
+        adapter="openai",
+        adapter_params={"model_name": "configured-embedding-model"},
+        yes=True,
+    )
+
+    config_text = (project_dir / "config/adapters/outbound/embedding.yaml").read_text(
+        encoding="utf-8"
+    )
+    env_text = (project_dir / ".env").read_text(encoding="utf-8")
+
+    assert "dimensions: null" in config_text
+    assert "api_key: null" in config_text
+    assert "OPENAI_API_KEY=" not in env_text
+    assert "sk-" not in config_text + env_text

arclith_cli-0.19.0/tests/test_vector_store_capability.py

@@ -0,0 +1,166 @@
+from pathlib import Path
+
+from arclith_cli.add_adapter import add_adapter_cmd
+from arclith_cli.capabilities import capability_catalog_as_dict, get_capability
+
+
+def _minimal_project(tmp_path: Path) -> Path:
+    project_dir = tmp_path / "demo-service"
+    (project_dir / "src" / "demo_service" / "domain" / "models").mkdir(parents=True)
+    config_dir = project_dir / "config" / "adapters"
+    config_dir.mkdir(parents=True)
+    (config_dir / "adapters.yaml").write_text(
+        "logger: console\nrepository: memory\nobservability:\n  enabled: []\n",
+        encoding="utf-8",
+    )
+    (project_dir / "pyproject.toml").write_text(
+        '[project]\nname = "demo-service"\nversion = "0.1.0"\n'
+        'dependencies = ["arclith>=0.22.0"]\n',
+        encoding="utf-8",
+    )
+    return project_dir
+
+
+def test_vector_store_capability_catalog_declares_memory_adapter() -> None:
+    capability = get_capability("vector-store")
+
+    assert capability is not None
+    assert capability.layer == "outbound"
+    assert capability.activation_config_key is None
+    assert capability.adapter_names() == ("memory", "qdrant")
+    memory = capability.get_adapter("memory")
+    assert memory is not None
+    assert memory.entity_scoped is False
+    assert memory.dependency_extra is None
+    assert memory.config_path == "config/adapters/outbound/vector_store.yaml"
+    assert [parameter.name for parameter in memory.parameters] == [
+        "collection_name",
+        "vector_size",
+        "distance",
+        "multitenant",
+    ]
+
+
+def test_vector_store_capability_is_exposed_in_json_catalog() -> None:
+    payload_by_name = {
+        capability["name"]: capability for capability in capability_catalog_as_dict()
+    }
+
+    vector_store = payload_by_name["vector-store"]
+    assert vector_store["activation_config_key"] is None
+    assert [adapter["name"] for adapter in vector_store["adapters"]] == [
+        "memory",
+        "qdrant",
+    ]
+
+
+def test_vector_store_capability_declares_qdrant_adapter() -> None:
+    capability = get_capability("vector-store")
+
+    assert capability is not None
+    qdrant = capability.get_adapter("qdrant")
+    assert qdrant is not None
+    assert qdrant.entity_scoped is False
+    assert qdrant.dependency_extra == "qdrant"
+    assert qdrant.config_path == "config/adapters/outbound/vector_store.yaml"
+    assert [mapping.field_path for mapping in qdrant.secret_mappings] == [
+        "adapters.vector_store.api_key",
+    ]
+    assert [mapping.secret_key for mapping in qdrant.secret_mappings] == [
+        "QDRANT_API_KEY",
+    ]
+
+
+def test_add_memory_vector_store_generates_loadable_config_idempotently(
+    tmp_path: Path,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+    params = {
+        "collection_name": "documents",
+        "vector_size": "3",
+        "distance": "cosine",
+        "multitenant": "false",
+    }
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="vector-store",
+            adapter="memory",
+            adapter_params=params,
+            yes=True,
+        )
+
+    from arclith import Arclith, MemoryVectorStore
+
+    config_path = project_dir / "config/adapters/outbound/vector_store.yaml"
+    app = Arclith(project_dir / "config")
+
+    assert config_path.read_text(encoding="utf-8") == (
+        "adapter: memory\n"
+        'collection_name: "documents"\n'
+        "vector_size: 3\n"
+        "distance: cosine\n"
+        "multitenant: false\n"
+    )
+    assert app.config.adapters.vector_store is not None
+    assert app.config.adapters.vector_store.vector_size == 3
+    assert isinstance(app.vector_store(), MemoryVectorStore)
+    assert "vector_store:" not in (
+        project_dir / "config/adapters/adapters.yaml"
+    ).read_text(encoding="utf-8")
+
+
+def test_add_qdrant_vector_store_generates_loadable_config_and_secrets(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    project_dir = _minimal_project(tmp_path)
+    params = {
+        "url": "http://localhost:6333",
+        "collection_name": "documents",
+        "vector_size": "1536",
+        "distance": "cosine",
+        "prefer_grpc": "false",
+        "timeout": "5.0",
+        "create_collection": "true",
+        "multitenant": "false",
+    }
+
+    for _ in range(2):
+        add_adapter_cmd(
+            project_dir=project_dir,
+            capability_name="vector-store",
+            adapter="qdrant",
+            adapter_params=params,
+            yes=True,
+        )
+
+    config_text = (
+        project_dir / "config/adapters/outbound/vector_store.yaml"
+    ).read_text(encoding="utf-8")
+    secrets_text = (project_dir / "config/secrets.yaml").read_text(encoding="utf-8")
+
+    assert config_text == (
+        "adapter: qdrant\n"
+        'url: "http://localhost:6333"\n'
+        "api_key: null\n"
+        'collection_name: "documents"\n'
+        "vector_size: 1536\n"
+        "distance: cosine\n"
+        "prefer_grpc: false\n"
+        "timeout: 5.0\n"
+        "create_collection: true\n"
+        "multitenant: false\n"
+    )
+    assert secrets_text.count("adapters.vector_store.api_key") == 1
+    assert "adapters.vector_store.api_key: QDRANT_API_KEY" in secrets_text
+    assert "adapters.vector_store.url" not in secrets_text
+
+    from arclith import Arclith, QdrantVectorStore
+
+    monkeypatch.setenv("QDRANT_API_KEY", "test-key")
+    app = Arclith(project_dir / "config")
+    assert isinstance(app.vector_store(), QdrantVectorStore)
+    assert app.config.adapters.vector_store is not None
+    assert app.config.adapters.vector_store.api_key == "test-key"

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

@@ -46,7 +46,7 @@ wheels = [
 
 [[package]]
 name = "arclith"
-version = "0.21.0"
+version = "0.22.0"
 source = { editable = "../" }
 dependencies = [
     { name = "fastapi" },
@@ -130,6 +130,8 @@ requires-dist = [
     { name = "pytz", marker = "extra == 'all'", specifier = "==2024.1" },
     { name = "pytz", marker = "extra == 'duckdb'", specifier = "==2024.1" },
     { name = "pyyaml", specifier = "==6.0.3" },
+    { name = "qdrant-client", marker = "extra == 'all'", specifier = "==1.19.0" },
+    { name = "qdrant-client", marker = "extra == 'qdrant'", specifier = "==1.19.0" },
     { name = "redis", marker = "extra == 'all'", specifier = ">=5.0.0" },
     { name = "redis", marker = "extra == 'cache'", specifier = ">=5.0.0" },
     { name = "redis", marker = "extra == 'langgraph-runtime'", specifier = ">=5.0.0" },
@@ -141,7 +143,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"]
+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"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -163,7 +165,7 @@ docs = [
 
 [[package]]
 name = "arclith-cli"
-version = "0.18.0"
+version = "0.19.0"
 source = { editable = "." }
 dependencies = [
     { name = "arclith" },

arclith_cli-0.18.0/arclith_cli/__init__.py

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