feat: preliminary implementation for daemon + CLI

Author: georgeh0

.pre-commit-config.yaml

@@ -25,7 +25,7 @@ repos:
     hooks:
       - id: mypy
         name: mypy
-        entry: uv run mypy src/
+        entry: uv run mypy src/ tests/
         language: system
         types: [python]
         pass_filenames: false

CLAUDE.md

@@ -6,8 +6,8 @@ This is built on top of [CocoIndex v1](https://cocoindex.io/docs-v1/llms.txt).
 This project uses [uv](https://docs.astral.sh/uv/) for project management.
 
 ```bash
-uv run mypy              # Type check Python code
-uv run pytest python/    # Run Python tests (use after both Rust and Python changes)
+uv run mypy .           # Type check Python code
+uv run pytest tests/    # Run Python tests
 ```
 
 ## Code Conventions

pyproject.toml

@@ -23,12 +23,15 @@ classifiers = [
 
 dependencies = [
     "mcp>=1.0.0",
-    "cocoindex[litellm]==1.0.0a29",
+    "cocoindex[litellm]==1.0.0a31",
     "sentence-transformers>=2.2.0",
     "sqlite-vec>=0.1.0",
     "pydantic>=2.0.0",
     "numpy>=1.24.0",
     "einops>=0.8.2",
+    "typer>=0.9.0",
+    "msgspec>=0.19.0",
+    "pyyaml>=6.0",
 ]
 
 [project.optional-dependencies]
@@ -43,6 +46,7 @@ dev = [
 
 [project.scripts]
 cocoindex-code = "cocoindex_code:main"
+ccc = "cocoindex_code.cli:app"
 
 [project.urls]
 Homepage = "https://github.com/cocoindex-io/cocoindex-code"
@@ -66,6 +70,7 @@ dev = [
     "ruff>=0.1.0",
     "mypy>=1.0.0",
     "prek>=0.1.0",
+    "types-pyyaml>=6.0.12.20250915",
 ]
 
 [tool.uv]

src/cocoindex_code/__init__.py

@@ -5,7 +5,6 @@
 logging.basicConfig(level=logging.WARNING)
 
 from ._version import __version__  # noqa: E402
-from .config import Config  # noqa: E402
-from .server import main, mcp  # noqa: E402
+from .server import main  # noqa: E402
 
-__all__ = ["Config", "main", "mcp", "__version__"]
+__all__ = ["main", "__version__"]

src/cocoindex_code/cli.py

@@ -0,0 +1,312 @@
+"""CLI entry point for cocoindex-code (ccc command)."""
+
+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 ProjectStatusResponse, SearchResponse
+from .settings import (
+    default_project_settings,
+    default_user_settings,
+    find_parent_with_marker,
+    find_project_root,
+    save_project_settings,
+    save_user_settings,
+    user_settings_path,
+)
+
+app = _typer.Typer(
+    name="ccc",
+    help="CocoIndex Code — index and search codebases.",
+    no_args_is_help=True,
+)
+
+daemon_app = _typer.Typer(name="daemon", help="Manage the daemon process.")
+app.add_typer(daemon_app, name="daemon")
+
+
+# ---------------------------------------------------------------------------
+# Shared CLI helpers (G1)
+# ---------------------------------------------------------------------------
+
+
+def require_project_root() -> Path:
+    """Find the project root by walking up from CWD.
+
+    Exits with code 1 if not found.
+    """
+    root = find_project_root(Path.cwd())
+    if root is None:
+        _typer.echo(
+            "Error: Not in an initialized project directory.\n"
+            "Run `ccc init` in your project root to get started.",
+            err=True,
+        )
+        raise _typer.Exit(code=1)
+    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()
+    try:
+        rel = cwd.relative_to(project_root)
+    except ValueError:
+        return None
+    if rel == Path("."):
+        return None
+    return f"{rel.as_posix()}/*"
+
+
+def print_index_stats(status: ProjectStatusResponse) -> None:
+    """Print formatted index statistics."""
+    _typer.echo("\nIndex stats:")
+    _typer.echo(f"  Chunks: {status.total_chunks}")
+    _typer.echo(f"  Files:  {status.total_files}")
+    if status.languages:
+        _typer.echo("  Languages:")
+        for lang, count in sorted(status.languages.items(), key=lambda x: -x[1]):
+            _typer.echo(f"    {lang}: {count} chunks")
+
+
+def print_search_results(response: SearchResponse) -> None:
+    """Print formatted search results."""
+    if not response.success:
+        _typer.echo(f"Search failed: {response.message}", err=True)
+        return
+
+    if not response.results:
+        _typer.echo("No results found.")
+        return
+
+    for i, r in enumerate(response.results, 1):
+        _typer.echo(f"\n--- Result {i} (score: {r.score:.3f}) ---")
+        _typer.echo(f"File: {r.file_path}:{r.start_line}-{r.end_line} [{r.language}]")
+        _typer.echo(r.content)
+
+
+# ---------------------------------------------------------------------------
+# Commands (G2-G5)
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def init(
+    force: bool = _typer.Option(False, "-f", "--force", help="Skip parent directory warning"),
+) -> None:
+    """Initialize a project for cocoindex-code."""
+    from .settings import project_settings_path
+
+    cwd = Path.cwd()
+    settings_file = project_settings_path(cwd)
+
+    # Check if already initialized
+    if settings_file.is_file():
+        _typer.echo("Project already initialized.")
+        return
+
+    # Check parent directories for markers
+    if not force:
+        parent = find_parent_with_marker(cwd)
+        if parent is not None and parent != cwd:
+            _typer.echo(
+                f"Warning: A parent directory has a project marker: {parent}\n"
+                "You might want to run `ccc init` there instead.\n"
+                "Use `ccc init -f` to initialize here anyway."
+            )
+            raise _typer.Exit(code=1)
+
+    # Create user settings if missing
+    user_path = user_settings_path()
+    if not user_path.is_file():
+        save_user_settings(default_user_settings())
+        _typer.echo(f"Created user settings: {user_path}")
+
+    # Create project settings
+    save_project_settings(cwd, default_project_settings())
+    _typer.echo(f"Created project settings: {settings_file}")
+    _typer.echo("Project initialized. Run `ccc index` to build the index.")
+
+
+@app.command()
+def index() -> None:
+    """Create/update index for the codebase."""
+    client, project_root = require_daemon_for_project()
+    _typer.echo("Indexing...")
+    try:
+        resp = client.index(project_root)
+    except RuntimeError as e:
+        _typer.echo(f"Indexing failed: {e}", err=True)
+        raise _typer.Exit(code=1)
+    if not resp.success:
+        _typer.echo(f"Indexing failed: {resp.message}", err=True)
+        raise _typer.Exit(code=1)
+
+    status = client.project_status(project_root)
+    print_index_stats(status)
+
+
+@app.command()
+def search(
+    query: list[str] = _typer.Argument(..., help="Search query"),
+    lang: list[str] = _typer.Option([], "--lang", help="Filter by language"),
+    path: str | None = _typer.Option(None, "--path", help="Filter by file path glob"),
+    offset: int = _typer.Option(0, "--offset", help="Number of results to skip"),
+    limit: int = _typer.Option(10, "--limit", help="Maximum results to return"),
+    refresh: bool = _typer.Option(False, "--refresh", help="Refresh index before searching"),
+) -> None:
+    """Semantic search across the codebase."""
+    client, project_root = require_daemon_for_project()
+    query_str = " ".join(query)
+
+    # Default path filter from CWD
+    paths: list[str] | None = None
+    if path is not None:
+        paths = [path]
+    else:
+        default = resolve_default_path(Path(project_root))
+        if default is not None:
+            paths = [default]
+
+    resp = client.search(
+        project_root=project_root,
+        query=query_str,
+        languages=lang or None,
+        paths=paths,
+        limit=limit,
+        offset=offset,
+        refresh=refresh,
+    )
+    print_search_results(resp)
+
+
+@app.command()
+def status() -> None:
+    """Show project status."""
+    client, project_root = require_daemon_for_project()
+    resp = client.project_status(project_root)
+    print_index_stats(resp)
+
+
+@app.command()
+def mcp() -> None:
+    """Run as MCP server (stdio mode)."""
+    import asyncio
+
+    client, project_root = require_daemon_for_project()
+
+    async def _run_mcp() -> None:
+        from .server import create_mcp_server
+
+        mcp_server = create_mcp_server(client, project_root)
+        # Trigger initial indexing in background
+        asyncio.create_task(_bg_index(client, project_root))
+        await mcp_server.run_stdio_async()
+
+    asyncio.run(_run_mcp())
+
+
+async def _bg_index(client, project_root: str) -> None:  # type: ignore[no-untyped-def]
+    """Index in background, swallowing errors."""
+    import asyncio
+
+    loop = asyncio.get_event_loop()
+    try:
+        await loop.run_in_executor(None, client.index, project_root)
+    except Exception:
+        pass
+
+
+# --- Daemon subcommands (G5) ---
+
+
+@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)
+
+    resp = client.daemon_status()
+    _typer.echo(f"Daemon version: {resp.version}")
+    _typer.echo(f"Uptime: {resp.uptime_seconds:.1f}s")
+    if resp.projects:
+        _typer.echo("Projects:")
+        for p in resp.projects:
+            state = "indexing" if p.indexing else "idle"
+            _typer.echo(f"  {p.project_root} [{state}]")
+    else:
+        _typer.echo("No projects loaded.")
+    client.close()
+
+
+@daemon_app.command("restart")
+def daemon_restart() -> None:
+    """Restart the daemon."""
+    from .client import _wait_for_daemon, start_daemon, stop_daemon
+
+    _typer.echo("Stopping daemon...")
+    stop_daemon()
+
+    _typer.echo("Starting daemon...")
+    start_daemon()
+    try:
+        _wait_for_daemon()
+        _typer.echo("Daemon restarted.")
+    except TimeoutError:
+        _typer.echo("Error: Daemon did not start in time.", err=True)
+        raise _typer.Exit(code=1)
+
+
+@daemon_app.command("stop")
+def daemon_stop() -> None:
+    """Stop the daemon."""
+    from .client import DaemonClient
+
+    try:
+        client = DaemonClient.connect()
+        client.handshake()
+        client.stop()
+        client.close()
+        _typer.echo("Daemon stopped.")
+    except (ConnectionRefusedError, OSError):
+        _typer.echo("Daemon is not running.")
+
+
+@app.command("run-daemon", hidden=True)
+def run_daemon_cmd() -> None:
+    """Internal: run the daemon process."""
+    from .daemon import run_daemon
+
+    run_daemon()
+
+
+# Allow running as module: python -m cocoindex_code.cli
+if __name__ == "__main__":
+    app()