feat(cli): migrate to async daemon client with watchdog dependency

- Add watchdog>=4.0.0 as project dependency
- Replace synchronous client calls with async DaemonClient implementation
- Update all CLI commands (compile, search, status, doctor, daemon-status)
  to use async client methods
- Refactor progress callbacks to async functions using asyncio.run()
- Move protocol imports from vectorless_code.client to
  vectorless_code.daemon.protocol
- Handle dictionary responses from daemon instead of typed objects
- Remove deprecated client.py module which contained old sync implementation

Author: zTgx

pyproject.toml

@@ -41,6 +41,7 @@ dependencies = [
     "msgspec>=0.18.0",
     "click>=8.0.0",
     "fastmcp>=0.1.0",
+    "watchdog>=4.0.0",
 ]
 
 [project.optional-dependencies]

src/vectorless_code/cli.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import functools
 import logging
 import os
@@ -15,8 +16,8 @@
 from vectorless_code import __version__
 
 logger = logging.getLogger(__name__)
-from vectorless_code.client import DaemonStartError, is_daemon_running, start_daemon, stop_daemon
-from vectorless_code.protocol import (
+from vectorless_code.daemon_client import DaemonStartError, is_daemon_running, start_daemon, stop_daemon
+from vectorless_code.daemon.protocol import (
     DoctorCheckResult,
     IndexingProgress,
     ProjectStatusResponse,
@@ -179,28 +180,30 @@ def _run_index_with_progress(project_root: str) -> None:
     from rich.live import Live
     from rich.spinner import Spinner
 
-    from vectorless_code import client as _client
+    from vectorless_code.daemon_client import DaemonClient
 
     err_console = Console(stderr=True)
     last_progress_line: str | None = None
 
     with Live(Spinner("dots", "Indexing..."), console=err_console, transient=True) as live:
 
-        def _on_waiting() -> None:
+        async def _on_progress_async(progress_data: dict) -> None:
+            nonlocal last_progress_line
+            progress = IndexingProgress(**progress_data)
+            last_progress_line = f"Indexing: {_format_progress(progress)}"
+            live.update(Spinner("dots", last_progress_line))
+
+        async def _on_waiting_async() -> None:
             live.update(
                 Spinner(
                     "dots",
                     "Another indexing is ongoing, waiting for it to finish...",
                 )
             )
 
-        def _on_progress(progress: IndexingProgress) -> None:
-            nonlocal last_progress_line
-            last_progress_line = f"Indexing: {_format_progress(progress)}"
-            live.update(Spinner("dots", last_progress_line))
-
         try:
-            resp = _client.index(project_root, on_progress=_on_progress, on_waiting=_on_waiting)
+            client = DaemonClient()
+            resp = asyncio.run(client.index(project_root, on_progress=_on_progress_async, on_waiting=_on_waiting_async))
         except RuntimeError as e:
             live.stop()
             if isinstance(e, DaemonStartError):
@@ -211,16 +214,17 @@ def _on_progress(progress: IndexingProgress) -> None:
     if last_progress_line is not None:
         typer.echo(last_progress_line, err=True)
 
-    if not resp.success:
-        typer.echo(f"Indexing failed: {resp.message}", err=True)
+    if not resp.get('success', False):
+        typer.echo(f"Indexing failed: {resp.get('message', 'Unknown error')}", err=True)
         raise typer.Exit(code=1)
 
-    typer.echo(f"Files:  {resp.file_count}")
-    typer.echo(f"Lines:  {resp.total_lines}")
-    typer.echo(f"Size:   {resp.total_bytes} bytes")
-    if resp.languages:
+    typer.echo(f"Files:  {resp.get('file_count', 0)}")
+    typer.echo(f"Lines:  {resp.get('total_lines', 0)}")
+    typer.echo(f"Size:   {resp.get('total_bytes', 0)} bytes")
+    languages = resp.get('languages', {})
+    if languages:
         typer.echo("Languages:")
-        for lang, count in sorted(resp.languages.items(), key=lambda x: -x[1]):
+        for lang, count in sorted(languages.items(), key=lambda x: -x[1]):
             typer.echo(f"  {lang}: {count}")
 
 
@@ -230,32 +234,33 @@ def _search_with_wait_spinner(
     doc_ids: list[str] | None = None,
     limit: int = 5,
     offset: int = 0,
-) -> SearchResponse:
+) -> dict:
     """Run search, showing a spinner if waiting for load-time indexing."""
     from rich.console import Console
     from rich.live import Live
     from rich.spinner import Spinner
 
-    from vectorless_code import client as _client
+    from vectorless_code.daemon_client import DaemonClient
 
     err_console = Console(stderr=True)
 
     with Live(Spinner("dots", "Searching..."), console=err_console, transient=True) as live:
 
-        def _on_waiting() -> None:
+        async def _on_waiting_async() -> None:
             live.update(
                 Spinner("dots", "Waiting for indexing to complete..."),
                 refresh=True,
             )
 
-        resp = _client.search(
+        client = DaemonClient()
+        resp = asyncio.run(client.search(
             project_root=project_root,
             query=query,
             doc_ids=doc_ids,
             limit=limit,
             offset=offset,
-            on_waiting=_on_waiting,
-        )
+            on_waiting=_on_waiting_async,
+        ))
 
     return resp
 
@@ -308,8 +313,6 @@ def init() -> None:
 @_catch_daemon_start_error
 def compile_cmd() -> None:
     """Compile the codebase into a searchable index."""
-    from vectorless_code import client as _client
-
     project_root = str(require_project_root())
     logger.info("Compiling project: %s", project_root)
     print_project_header(project_root)
@@ -323,36 +326,57 @@ def ask(
     question: list[str] = typer.Argument(..., help="Question about the codebase"),
 ) -> None:
     """Ask a question about the codebase."""
-    from vectorless_code import client as _client
-
     project_root = str(require_project_root())
     query_str = " ".join(question)
 
     logger.info("Querying project %s: %s", project_root, query_str[:100])
     print_project_header(project_root)
 
-    resp = _search_with_wait_spinner(
+    resp_dict = _search_with_wait_spinner(
         project_root=project_root,
         query=query_str,
         limit=10,
     )
-    print_search_results(resp)
+    print_search_results(SearchResponse(**resp_dict))
 
 
 @app.command()
 @_catch_daemon_start_error
 def status() -> None:
     """Show compilation status and index statistics."""
-    from vectorless_code import client as _client
+    from vectorless_code.daemon_client import DaemonClient
 
     project_root_path = require_project_root()
     project_root = str(project_root_path)
     print_project_header(project_root)
 
     typer.echo(f"Settings: {settings_path(project_root_path)}")
 
-    st = _client.project_status(project_root)
-    print_index_stats(st)
+    try:
+        client = DaemonClient()
+        resp = asyncio.run(client.project_status(project_root))
+        
+        # Adapt dictionary response to ProjectStatusResponse or handle directly
+        # Assuming the daemon returns a dict that can be unpacked or handled
+        # If strict typing is needed, we might construct ProjectStatusResponse if fields match
+        # For now, printing basic info based on typical status response
+        
+        if resp.get('indexed', False):
+            typer.echo("Status: Indexed")
+            typer.echo(f"Files:  {resp.get('file_count', 0)}")
+            typer.echo(f"Nodes:  {resp.get('node_count', 0)}")
+            typer.echo(f"Size:   {resp.get('total_bytes', 0)} bytes")
+            if 'last_modified' in resp:
+                typer.echo(f"Last modified: {resp['last_modified']}")
+        else:
+            typer.echo("Status: Not indexed")
+            typer.echo("Run `vcc compile` to build the index.")
+
+    except RuntimeError as e:
+        if isinstance(e, DaemonStartError):
+            raise
+        typer.echo(f"Failed to get status: {e}", err=True)
+        raise typer.Exit(code=1)
 
 
 @app.command()
@@ -468,21 +492,32 @@ def doctor() -> None:
     _print_section("Daemon")
     daemon_ok = False
     try:
-        st = _client.daemon_status()
-        typer.echo(f"  Version: {st.version}")
-        typer.echo(f"  Uptime: {st.uptime_seconds:.1f}s")
-        typer.echo(f"  Loaded projects: {len(st.projects)}")
+        from vectorless_code.daemon_client import DaemonClient
+        client = DaemonClient()
+        st_dict = asyncio.run(client.daemon_status())
+        # Construct a simple object or access dict keys
+        # Assuming st_dict has version, uptime_seconds, projects
+        typer.echo(f"  Version: {st_dict.get('version', 'unknown')}")
+        typer.echo(f"  Uptime: {st_dict.get('uptime_seconds', 0):.1f}s")
+        projects = st_dict.get('projects', [])
+        typer.echo(f"  Loaded projects: {len(projects)}")
         daemon_ok = True
     except Exception as e:
         _print_error(f"Cannot connect to daemon: {e}")
 
     if daemon_ok:
         try:
-            env_resp = _client.daemon_env()
-            if env_resp.path_mappings:
+            client = DaemonClient()
+            env_resp_dict = asyncio.run(client.daemon_env())
+            path_mappings = env_resp_dict.get('path_mappings', [])
+            if path_mappings:
                 typer.echo("  Path mappings:")
-                for m in env_resp.path_mappings:
-                    typer.echo(f"    {m.source} → {m.target}")
+                for m in path_mappings:
+                    # m might be a dict or object depending on daemon protocol serialization
+                    if isinstance(m, dict):
+                        typer.echo(f"    {m.get('source')} → {m.get('target')}")
+                    else:
+                        typer.echo(f"    {m.source} → {m.target}")
         except Exception as e:
             _print_error(f"Failed to get daemon env: {e}")
 
@@ -495,9 +530,14 @@ def doctor() -> None:
 
         if daemon_ok:
             try:
-                _client.doctor(
+                client = DaemonClient()
+                
+                async def _on_result_async(result_data: dict) -> None:
+                    _print_doctor_result(DoctorCheckResult(**result_data))
+
+                await client.doctor(
                     project_root=str(project_root),
-                    on_result=_print_doctor_result,
+                    on_result=_on_result_async,
                 )
             except Exception as e:
                 _print_error(f"Project checks failed: {e}")
@@ -536,16 +576,26 @@ async def _run_mcp() -> None:
 @_catch_daemon_start_error
 def daemon_status() -> None:
     """Show daemon status."""
-    from vectorless_code import client as _client
-
-    resp = _client.daemon_status()
-    typer.echo(f"Daemon version: {resp.version}")
-    typer.echo(f"Uptime: {resp.uptime_seconds:.1f}s")
-    if resp.projects:
+    from vectorless_code.daemon_client import DaemonClient
+
+    client = DaemonClient()
+    resp_dict = asyncio.run(client.daemon_status())
+    
+    typer.echo(f"Daemon version: {resp_dict.get('version', 'unknown')}")
+    typer.echo(f"Uptime: {resp_dict.get('uptime_seconds', 0):.1f}s")
+    projects = resp_dict.get('projects', [])
+    if projects:
         typer.echo("Projects:")
-        for p in resp.projects:
-            state = "indexing" if p.indexing else "idle"
-            typer.echo(f"  {p.project_root} [{state}]")
+        for p in projects:
+            # p might be dict or object
+            if isinstance(p, dict):
+                root = p.get('project_root', 'unknown')
+                indexing = p.get('indexing', False)
+            else:
+                root = p.project_root
+                indexing = p.indexing
+            state = "indexing" if indexing else "idle"
+            typer.echo(f"  {root} [{state}]")
     else:
         typer.echo("No projects loaded.")