refactor(cli): drop now use the DB adapter layer.

Author: Zhe Yu

src/vectorcode/cli_utils.py

@@ -105,7 +105,6 @@ class Config:
     include: list[QueryInclude] = field(
         default_factory=lambda: [QueryInclude.path, QueryInclude.document]
     )
-    hnsw: dict[str, str | int] = field(default_factory=dict)
     chunk_filters: dict[str, list[str]] = field(default_factory=dict)
     filetype_map: dict[str, list[str]] = field(default_factory=dict)
     encoding: str = "utf8"
@@ -144,10 +143,6 @@ async def import_from(cls, config_dict: dict[str, Any]) -> "Config":
                 ),
                 "db_type": config_dict.get("db_type", default_config.db_type),
                 "db_params": config_dict.get("db_url", default_config.db_params),
-                "db_path": db_path,
-                "db_log_path": os.path.expanduser(
-                    config_dict.get("db_log_path", default_config.db_log_path)
-                ),
                 "chunk_size": config_dict.get("chunk_size", default_config.chunk_size),
                 "overlap_ratio": config_dict.get(
                     "overlap_ratio", default_config.overlap_ratio
@@ -159,10 +154,6 @@ async def import_from(cls, config_dict: dict[str, Any]) -> "Config":
                 "reranker_params": config_dict.get(
                     "reranker_params", default_config.reranker_params
                 ),
-                "db_settings": config_dict.get(
-                    "db_settings", default_config.db_settings
-                ),
-                "hnsw": config_dict.get("hnsw", default_config.hnsw),
                 "chunk_filters": config_dict.get(
                     "chunk_filters", default_config.chunk_filters
                 ),

src/vectorcode/database/chroma0.py

@@ -17,13 +17,15 @@
 from chromadb.api.models.AsyncCollection import AsyncCollection
 from chromadb.api.types import EmbeddingFunction, IncludeEnum, QueryResult
 from chromadb.config import APIVersion, Settings
+from chromadb.errors import InvalidCollectionException
 from tree_sitter import Point
 
 import vectorcode.subcommands.query.types as vectorcode_query_types
 from vectorcode.chunking import Chunk, TreeSitterChunker
 from vectorcode.cli_utils import Config, LockManager, expand_path
 from vectorcode.common import get_embedding_function
 from vectorcode.database.base import DatabaseConnectorBase
+from vectorcode.database.errors import CollectionNotFoundError
 from vectorcode.database.types import (
     CollectionContent,
     CollectionInfo,
@@ -170,7 +172,7 @@ async def get_client(self, configs: Config, need_lock: bool = True):
             process = None
             if not await _try_server(url):
                 logger.info(f"Starting a new server at {url}")
-                process = await _start_server(url)
+                process = await _start_server(configs)
                 is_bundled = True
 
             self.__clients[project_root] = _Chroma0ClientModel(
@@ -223,7 +225,7 @@ def clear(self):
         self.__clients.clear()
 
 
-__default_settings: dict[str, Any] = {
+_default_settings: dict[str, Any] = {
     "db_url": "http://127.0.0.1",
     "db_path": os.path.expanduser("~/.local/share/vectorcode/chromadb/"),
     "db_log_path": os.path.expanduser("~/.local/share/vectorcode/"),
@@ -246,7 +248,7 @@ class ChromaDB0Connector(DatabaseConnectorBase):
 
     def __init__(self, configs: Config):
         super().__init__(configs)
-        params = copy.deepcopy(__default_settings)
+        params = copy.deepcopy(_default_settings)
         params.update(self._configs.db_params)
         self._configs.db_params = params
 
@@ -294,12 +296,18 @@ async def _create_or_get_collection(
             meta_field_name: str = key
             if not meta_field_name.startswith("hnsw:"):
                 meta_field_name = f"hnsw:{meta_field_name}"
-            collection_meta[meta_field_name] = db_params[key]
+            if db_params.get(key) is not None:
+                collection_meta[meta_field_name] = db_params[key]
 
         async with Chroma0ClientManager().get_client(self._configs, True) as client:
             collection_id = get_collection_id(collection_path)
             if not allow_create:
-                return await client.get_collection(collection_id)
+                try:
+                    return await client.get_collection(collection_id)
+                except (InvalidCollectionException, ValueError) as e:
+                    raise CollectionNotFoundError(
+                        f"There's no existing collection for {collection_path} in ChromaDB0 {self._configs.db_params.get('db_url')}"
+                    ) from e
             col = await client.get_or_create_collection(
                 collection_id, metadata=collection_meta
             )
@@ -448,4 +456,5 @@ async def delete(self, collection_path: str, file_path: str | Sequence[str]):
 
     async def drop(self, collection_path: str):
         async with Chroma0ClientManager().get_client(self._configs) as client:
+            await self._create_or_get_collection(collection_path, False)
             await client.delete_collection(get_collection_id(collection_path))

src/vectorcode/database/errors.py

@@ -0,0 +1,6 @@
+class CollectionNotFoundError(Exception):
+    """
+    When a requested collection doesn't exist in the database.
+    """
+
+    pass

src/vectorcode/subcommands/drop.py

@@ -1,24 +1,19 @@
 import logging
 
-from chromadb.errors import InvalidCollectionException
-
 from vectorcode.cli_utils import Config
-from vectorcode.common import ClientManager, get_collection
+from vectorcode.database.chroma0 import ChromaDB0Connector
+from vectorcode.database.errors import CollectionNotFoundError
 
 logger = logging.getLogger(name=__name__)
 
 
 async def drop(config: Config) -> int:
-    async with ClientManager().get_client(config) as client:
-        try:
-            collection = await get_collection(client, config)
-            collection_path = collection.metadata["path"]
-            await client.delete_collection(collection.name)
-            print(f"Collection for {collection_path} has been deleted.")
-            logger.info(f"Deteted collection at {collection_path}.")
-            return 0
-        except (ValueError, InvalidCollectionException) as e:
-            logger.error(
-                f"{e.__class__.__name__}: There's no existing collection for {config.project_root}"
-            )
-            return 1
+    database = ChromaDB0Connector(config)
+    try:
+        await database.drop(str(config.project_root))
+        if not config.pipe:
+            print(f"Collection for {config.project_root} has been deleted.")
+        return 0
+    except CollectionNotFoundError:
+        logger.warning(f"Collection for {config.project_root} doesn't exist.")
+        return 1