feat: Fix singleton implementation for LockManager and ClientManager

Author: Davidyz

src/vectorcode/cli_utils.py

@@ -619,13 +619,13 @@ class LockManager:
     """
 
     __locks: dict[str, AsyncFileLock]
-    __singleton: "LockManager"
+    singleton: Optional["LockManager"] = None
 
     def __new__(cls) -> "LockManager":
-        if not hasattr(cls, "__singleton") or cls.__singleton is None:
-            cls.__singleton = super().__new__(cls)
-            cls.__singleton.__locks = {}
-        return cls.__singleton
+        if cls.singleton is None:
+            cls.singleton = super().__new__(cls)
+            cls.singleton.__locks = {}
+        return cls.singleton
 
     def get_lock(self, path: str | os.PathLike) -> AsyncFileLock:
         path = str(expand_path(str(path), True))

src/vectorcode/common.py

@@ -248,14 +248,14 @@ class _ClientModel:
 
 
 class ClientManager:
-    __singleton: Optional["ClientManager"] = None
+    singleton: Optional["ClientManager"] = None
     __clients: dict[str, _ClientModel]
 
     def __new__(cls) -> "ClientManager":
-        if not hasattr(cls, "__singleton") or cls.__singleton is None:
-            cls.__singleton = super().__new__(cls)
-            cls.__singleton.__clients = {}
-        return cls.__singleton
+        if cls.singleton is None:
+            cls.singleton = super().__new__(cls)
+            cls.singleton.__clients = {}
+        return cls.singleton
 
     @contextlib.asynccontextmanager
     async def get_client(self, configs: Config, need_lock: bool = True):

src/vectorcode/mcp_main.py

@@ -188,7 +188,7 @@ async def query_tool(
         async with ClientManager().get_client(config) as client:
             collection = await get_collection(client, config, False)
 
-            if collection is None:
+            if collection is None:  # pragma: nocover
                 raise McpError(
                     ErrorData(
                         code=1,

tests/test_common.py

@@ -509,15 +509,19 @@ async def test_wait_for_server_timeout():
 
 @pytest.mark.asyncio
 async def test_client_manager_get_client():
-    config = Config(db_url="https://test_host:1234", db_path="test_db")
+    config = Config(
+        db_url="https://test_host:1234", db_path="test_db", project_root="test_proj"
+    )
     config1 = Config(
         db_url="http://test_host1:1234",
         db_path="test_db",
+        project_root="test_proj1",
         db_settings={"anonymized_telemetry": True},
     )
     config1_alt = Config(
         db_url="http://test_host1:1234",
         db_path="test_db",
+        project_root="test_proj1",
         db_settings={"anonymized_telemetry": True, "other_setting": "value"},
     )
     # Patch chromadb.AsyncHttpClient to avoid actual network calls
@@ -580,6 +584,42 @@ async def test_client_manager_get_client():
                 assert id(client1_alt) == id(client1)
 
 
+@pytest.mark.asyncio
+async def test_client_manager_list_server_processes():
+    async def _try_server(url):
+        return "127.0.0.1" in url or "localhost" in url
+
+    async def _start_server(cfg):
+        return AsyncMock()
+
+    with (
+        tempfile.TemporaryDirectory() as temp_dir,
+        patch("vectorcode.common.start_server", side_effect=_start_server),
+        patch("vectorcode.common.try_server", side_effect=_try_server),
+    ):
+        db_path = os.path.join(temp_dir, "db")
+        os.makedirs(db_path, exist_ok=True)
+
+        ClientManager._create_client = AsyncMock()
+        async with ClientManager().get_client(
+            Config(
+                db_url="http://test_host:8001",
+                project_root="proj1",
+                db_path=db_path,
+            )
+        ):
+            print(ClientManager().get_processes())
+        async with ClientManager().get_client(
+            Config(
+                db_url="http://test_host:8002",
+                project_root="proj2",
+                db_path=db_path,
+            )
+        ):
+            pass
+        assert len(ClientManager().get_processes()) == 2
+
+
 @pytest.mark.asyncio
 async def test_client_manager_kill_servers():
     manager = ClientManager()
@@ -596,5 +636,6 @@ async def _try_server(url):
         manager._create_client = AsyncMock(return_value=AsyncMock())
         async with manager.get_client(Config(db_url="http://test_host:1081")):
             pass
+        assert len(manager.get_processes()) == 1
         await manager.kill_servers()
         mock_process.terminate.assert_called_once()

tests/test_mcp.py

@@ -87,6 +87,7 @@ async def test_query_tool_invalid_project_root():
 @pytest.mark.asyncio
 async def test_query_tool_success():
     with (
+        tempfile.TemporaryDirectory() as temp_dir,
         patch("os.path.isdir", return_value=True),
         patch("vectorcode.mcp_main.get_project_config") as mock_get_project_config,
         patch("vectorcode.mcp_main.get_collection") as mock_get_collection,
@@ -101,7 +102,9 @@ async def test_query_tool_success():
     ):
         from vectorcode.mcp_main import ClientManager
 
-        mock_config = Config(chunk_size=100, overlap_ratio=0.1, reranker=None)
+        mock_config = Config(
+            chunk_size=100, overlap_ratio=0.1, reranker=None, project_root=temp_dir
+        )
         mock_load_config_file.return_value = mock_config
         mock_get_project_config.return_value = mock_config
         mock_client = AsyncMock()
@@ -126,7 +129,7 @@ async def test_query_tool_success():
         mock_open.return_value = mock_file_handle
 
         result = await query_tool(
-            n_query=2, query_messages=["keyword1"], project_root="/valid/path"
+            n_query=2, query_messages=["keyword1"], project_root=temp_dir
         )
 
         assert len(result) == 2