cocoindex-code 0.2.4__tar.gz → 0.2.6__tar.gz

{cocoindex_code-0.2.4 → cocoindex_code-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex-code
-Version: 0.2.4
+Version: 0.2.6
 Summary: MCP server for indexing and querying codebases using CocoIndex
 Project-URL: Homepage, https://github.com/cocoindex-io/cocoindex-code
 Project-URL: Repository, https://github.com/cocoindex-io/cocoindex-code
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
-Requires-Dist: cocoindex[litellm]==1.0.0a35
+Requires-Dist: cocoindex[litellm]==1.0.0a37
 Requires-Dist: einops>=0.8.2
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: msgspec>=0.19.0

{cocoindex_code-0.2.4 → cocoindex_code-0.2.6}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 
 dependencies = [
     "mcp>=1.0.0",
-    "cocoindex[litellm]==1.0.0a35",
+    "cocoindex[litellm]==1.0.0a37",
     "sentence-transformers>=2.2.0",
     "sqlite-vec>=0.1.0",
     "pydantic>=2.0.0",

{cocoindex_code-0.2.4 → cocoindex_code-0.2.6}/src/cocoindex_code/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)
 
 __commit_id__ = commit_id = None

{cocoindex_code-0.2.4 → cocoindex_code-0.2.6}/src/cocoindex_code/cli.py

@@ -3,14 +3,10 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import typer as _typer
 
-if TYPE_CHECKING:
-    from .client import DaemonClient
-
-from .protocol import IndexingProgress, ProjectStatusResponse, SearchResponse
+from .protocol import DoctorCheckResult, IndexingProgress, ProjectStatusResponse, SearchResponse
 from .settings import (
     default_project_settings,
     default_user_settings,
@@ -52,22 +48,6 @@ def require_project_root() -> Path:
     return root
 
 
-def require_daemon_for_project() -> tuple[DaemonClient, str]:
-    """Resolve project root, then connect to daemon (auto-starting if needed).
-
-    Returns ``(client, project_root_str)``. Exits on failure.
-    """
-    from .client import ensure_daemon
-
-    project_root = require_project_root()
-    try:
-        client = ensure_daemon()
-    except Exception as e:
-        _typer.echo(f"Error: Failed to connect to daemon: {e}", err=True)
-        raise _typer.Exit(code=1)
-    return client, str(project_root)
-
-
 def resolve_default_path(project_root: Path) -> str | None:
     """Compute default ``--path`` filter from CWD relative to project root."""
     cwd = Path.cwd().resolve()
@@ -101,7 +81,7 @@ def print_index_stats(status: ProjectStatusResponse) -> None:
     if status.progress is not None:
         _typer.echo(f"Indexing in progress: {_format_progress(status.progress)}")
     if not status.index_exists:
-        _typer.echo("\nIndex not created yet. Run `ccc index` to build the index.")
+        _typer.echo("\nIndex not created yet.")
         return
     _typer.echo("\nIndex stats:")
     _typer.echo(f"  Chunks: {status.total_chunks}")
@@ -128,12 +108,14 @@ def print_search_results(response: SearchResponse) -> None:
         _typer.echo(r.content)
 
 
-def _run_index_with_progress(client: DaemonClient, project_root: str) -> None:
+def _run_index_with_progress(project_root: str) -> None:
     """Run indexing with streaming progress display. Exits on failure."""
     from rich.console import Console as _Console
     from rich.live import Live as _Live
     from rich.spinner import Spinner as _Spinner
 
+    from . import client as _client
+
     err_console = _Console(stderr=True)
     last_progress_line: str | None = None
 
@@ -153,7 +135,7 @@ def _run_index_with_progress(client: DaemonClient, project_root: str) -> None:
             live.update(_Spinner("dots", last_progress_line))
 
         try:
-            resp = client.index(project_root, on_progress=_on_progress, on_waiting=_on_waiting)
+            resp = _client.index(project_root, on_progress=_on_progress, on_waiting=_on_waiting)
         except RuntimeError as e:
             live.stop()
             _typer.echo(f"Indexing failed: {e}", err=True)
@@ -169,7 +151,6 @@ def _run_index_with_progress(client: DaemonClient, project_root: str) -> None:
 
 
 def _search_with_wait_spinner(
-    client: DaemonClient,
     project_root: str,
     query: str,
     languages: list[str] | None = None,
@@ -182,6 +163,8 @@ def _search_with_wait_spinner(
     from rich.live import Live as _Live
     from rich.spinner import Spinner as _Spinner
 
+    from . import client as _client
+
     err_console = _Console(stderr=True)
 
     with _Live(_Spinner("dots", "Searching..."), console=err_console, transient=True) as live:
@@ -192,7 +175,7 @@ def _search_with_wait_spinner(
                 refresh=True,
             )
 
-        resp = client.search(
+        resp = _client.search(
             project_root=project_root,
             query=query,
             languages=languages,
@@ -305,13 +288,12 @@ def init(
 @app.command()
 def index() -> None:
     """Create/update index for the codebase."""
-    client, project_root = require_daemon_for_project()
-    print_project_header(project_root)
-
-    _run_index_with_progress(client, project_root)
+    from . import client as _client
 
-    status = client.project_status(project_root)
-    print_index_stats(status)
+    project_root = str(require_project_root())
+    print_project_header(project_root)
+    _run_index_with_progress(project_root)
+    print_index_stats(_client.project_status(project_root))
 
 
 @app.command()
@@ -324,12 +306,11 @@ def search(
     refresh: bool = _typer.Option(False, "--refresh", help="Refresh index before searching"),
 ) -> None:
     """Semantic search across the codebase."""
-    client, project_root = require_daemon_for_project()
+    project_root = str(require_project_root())
     query_str = " ".join(query)
 
-    # Refresh index with progress display before searching
     if refresh:
-        _run_index_with_progress(client, project_root)
+        _run_index_with_progress(project_root)
 
     # Default path filter from CWD
     paths: list[str] | None = None
@@ -341,7 +322,6 @@ def search(
             paths = [default]
 
     resp = _search_with_wait_spinner(
-        client,
         project_root=project_root,
         query=query_str,
         languages=lang or None,
@@ -355,10 +335,11 @@ def search(
 @app.command()
 def status() -> None:
     """Show project status."""
-    client, project_root = require_daemon_for_project()
+    from . import client as _client
+
+    project_root = str(require_project_root())
     print_project_header(project_root)
-    resp = client.project_status(project_root)
-    print_index_stats(resp)
+    print_index_stats(_client.project_status(project_root))
 
 
 @app.command()
@@ -400,12 +381,9 @@ def reset(
 
     # Remove project from daemon first so it releases file handles
     try:
-        from .client import DaemonClient
+        from . import client as _client
 
-        client = DaemonClient.connect()
-        client.handshake()
-        client.remove_project(str(project_root))
-        client.close()
+        _client.remove_project(str(project_root))
     except (ConnectionRefusedError, OSError, RuntimeError):
         pass  # Daemon not running — that's fine
 
@@ -437,18 +415,154 @@ def reset(
             )
 
 
+def _print_section(name: str) -> None:
+    import click as _click
+
+    _typer.echo()
+    _typer.echo(_click.style(f"  {name}", bold=True))
+    _typer.echo(_click.style(f"  {'─' * 38}", fg="bright_black"))
+
+
+def _print_error(msg: str) -> None:
+    import click as _click
+
+    _typer.echo(_click.style(f"  ERROR: {msg}", fg="red"), err=True)
+
+
+def _print_doctor_result(result: DoctorCheckResult) -> None:
+    import click as _click
+
+    if result.name == "done":
+        return
+    if result.ok:
+        tag = _click.style("[OK]", fg="green", bold=True)
+    else:
+        tag = _click.style("[FAIL]", fg="red", bold=True)
+    _typer.echo(f"\n  {tag} {result.name}")
+    for line in result.details:
+        _typer.echo(f"    {line}")
+    for err in result.errors:
+        _typer.echo(_click.style(f"    ERROR: {err}", fg="red"), err=True)
+
+
+@app.command()
+def doctor() -> None:
+    """Check system health and report issues."""
+    from . import client as _client
+    from .settings import (
+        load_project_settings as _load_project_settings,
+    )
+    from .settings import (
+        load_user_settings as _load_user_settings,
+    )
+    from .settings import (
+        project_settings_path as _project_settings_path,
+    )
+    from .settings import (
+        user_settings_path as _user_settings_path,
+    )
+
+    # --- 1. Global settings (local, no daemon needed) ---
+    _print_section("Global Settings")
+    settings_path = _user_settings_path()
+    _typer.echo(f"  Settings: {settings_path}")
+    try:
+        user_settings = _load_user_settings()
+        emb = user_settings.embedding
+        device_str = f", device={emb.device}" if emb.device else ""
+        _typer.echo(f"  Embedding: provider={emb.provider}, model={emb.model}{device_str}")
+        if user_settings.envs:
+            _typer.echo(
+                f"  Env vars (from settings): {', '.join(sorted(user_settings.envs.keys()))}"
+            )
+    except (FileNotFoundError, ValueError) as e:
+        _print_error(str(e))
+
+    # --- 2. Connect to daemon (handshake with auto-start/restart) ---
+    _print_section("Daemon")
+    daemon_ok = False
+    try:
+        status = _client.daemon_status()
+        _typer.echo(f"  Version: {status.version}")
+        _typer.echo(f"  Uptime: {status.uptime_seconds:.1f}s")
+        _typer.echo(f"  Loaded projects: {len(status.projects)}")
+        daemon_ok = True
+    except Exception as e:
+        _print_error(f"Cannot connect to daemon: {e}")
+        _typer.echo("  Remaining daemon-side checks will be skipped.")
+
+    # --- 3. Daemon environment (requires daemon) ---
+    if daemon_ok:
+        try:
+            env_resp = _client.daemon_env()
+            settings_keys = set(env_resp.settings_env_names)
+            other_keys = [k for k in env_resp.env_names if k not in settings_keys]
+            if other_keys:
+                _typer.echo(f"  Other env vars in daemon: {', '.join(sorted(other_keys))}")
+        except Exception as e:
+            _print_error(f"Failed to get daemon env: {e}")
+
+    # --- 4. Model check (daemon-side, global — before project checks) ---
+    if daemon_ok:
+        try:
+            _client.doctor(
+                project_root=None,
+                on_result=_print_doctor_result,
+            )
+        except Exception as e:
+            _print_error(f"Model check failed: {e}")
+
+    # --- 5. Detect project ---
+    project_root = find_project_root(Path.cwd())
+
+    # --- 6. Project settings (local, no daemon needed) ---
+    if project_root is not None:
+        _print_section("Project Settings")
+        ps_path = _project_settings_path(project_root)
+        _typer.echo(f"  Settings: {ps_path}")
+        try:
+            ps = _load_project_settings(project_root)
+            _typer.echo(f"  Include patterns ({len(ps.include_patterns)}):")
+            _typer.echo(f"    {', '.join(ps.include_patterns)}")
+            _typer.echo(f"  Exclude patterns ({len(ps.exclude_patterns)}):")
+            _typer.echo(f"    {', '.join(ps.exclude_patterns)}")
+            if ps.language_overrides:
+                _typer.echo("  Language overrides:")
+                for lo in ps.language_overrides:
+                    _typer.echo(f"    .{lo.ext} -> {lo.lang}")
+        except (FileNotFoundError, ValueError) as e:
+            _print_error(str(e))
+
+    # --- 7. Project daemon-side checks (file walk + index status) ---
+    if daemon_ok and project_root is not None:
+        try:
+            _client.doctor(
+                project_root=str(project_root),
+                on_result=_print_doctor_result,
+            )
+        except Exception as e:
+            _print_error(f"Project checks failed: {e}")
+
+    # --- 8. Log files ---
+    _print_section("Log Files")
+    from .daemon import daemon_dir as _daemon_dir
+
+    log_dir = _daemon_dir()
+    _typer.echo(f"  Daemon logs: {log_dir / 'daemon.log'}")
+    _typer.echo("  Check logs above for further troubleshooting.")
+
+
 @app.command()
 def mcp() -> None:
     """Run as MCP server (stdio mode)."""
     import asyncio
 
-    client, project_root = require_daemon_for_project()
+    project_root = str(require_project_root())
 
     async def _run_mcp() -> None:
         from .server import create_mcp_server
 
-        mcp_server = create_mcp_server(client, project_root)
-        # Trigger initial indexing in background
+        mcp_server = create_mcp_server(project_root)
         asyncio.create_task(_bg_index(project_root))
         await mcp_server.run_stdio_async()
 
@@ -456,27 +570,14 @@ def mcp() -> None:
 
 
 async def _bg_index(project_root: str) -> None:
-    """Index in background using a dedicated daemon connection.
-
-    A fresh DaemonClient is used so that background indexing does not share
-    the multiprocessing connection used by foreground MCP requests, which
-    would corrupt data ("Input data was truncated").
-    """
+    """Index in background. Each call opens its own daemon connection."""
     import asyncio
 
-    from .client import ensure_daemon
+    from . import client as _client
 
     loop = asyncio.get_event_loop()
-
-    def _run_index() -> None:
-        bg_client = ensure_daemon()
-        try:
-            bg_client.index(project_root)
-        finally:
-            bg_client.close()
-
     try:
-        await loop.run_in_executor(None, _run_index)
+        await loop.run_in_executor(None, lambda: _client.index(project_root))
     except Exception:
         pass
 
@@ -487,15 +588,9 @@ async def _bg_index(project_root: str) -> None:
 @daemon_app.command("status")
 def daemon_status() -> None:
     """Show daemon status."""
-    from .client import ensure_daemon
-
-    try:
-        client = ensure_daemon()
-    except Exception as e:
-        _typer.echo(f"Error: {e}", err=True)
-        raise _typer.Exit(code=1)
+    from . import client as _client
 
-    resp = client.daemon_status()
+    resp = _client.daemon_status()
     _typer.echo(f"Daemon version: {resp.version}")
     _typer.echo(f"Uptime: {resp.uptime_seconds:.1f}s")
     if resp.projects:
@@ -505,7 +600,6 @@ def daemon_status() -> None:
             _typer.echo(f"  {p.project_root} [{state}]")
     else:
         _typer.echo("No projects loaded.")
-    client.close()
 
 
 @daemon_app.command("restart")