code-context-mcp 1.0.0__py3-none-any.whl

code_context/domain/use_cases/indexer.py

@@ -0,0 +1,336 @@
+"""IndexerUseCase — orchestrates the 5 ports for full + incremental reindex."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+
+from code_context.domain.models import IndexEntry, StaleSet, SymbolDef
+from code_context.domain.ports import (
+    Chunker,
+    CodeSource,
+    EmbeddingsProvider,
+    GitSource,
+    KeywordIndex,
+    SymbolIndex,
+    VectorStore,
+)
+
+log = logging.getLogger(__name__)
+
+_BATCH_SIZE = 64
+_CURRENT_FILE = "current.json"
+# v1: original schema (no file_hashes).
+# v2: Sprint 6 — adds file_hashes for incremental reindex.
+_VERSION = 2
+
+
+@dataclass
+class IndexerUseCase:
+    cache_dir: Path
+    repo_root: Path
+    embeddings: EmbeddingsProvider
+    vector_store: VectorStore
+    keyword_index: KeywordIndex
+    symbol_index: SymbolIndex
+    chunker: Chunker
+    code_source: CodeSource
+    git_source: GitSource
+    include_extensions: list[str]
+    max_file_bytes: int = 1_048_576
+
+    # ---------- public ----------
+
+    def dirty_set(self) -> StaleSet:
+        """Verdict that drives Sprint 6's incremental reindex.
+
+        Returns a StaleSet whose `full_reindex_required` is True for any
+        of these blow-it-all-away conditions: no current index, no git
+        repo, metadata schema older than v2 (i.e. file_hashes absent),
+        or any global version (embeddings model id, chunker version,
+        keyword/symbol index version) changed since last index. Otherwise
+        compares the per-file content SHA of every currently-indexable
+        file against `metadata.file_hashes`; mismatches go to
+        `dirty_files`, vanished entries go to `deleted_files`. Both
+        empty + flag False = "no work" steady state.
+        """
+        active = self._current_metadata()
+        if active is None:
+            return StaleSet(full_reindex_required=True, reason="no current index")
+        if not self.git_source.is_repo(self.repo_root):
+            return StaleSet(full_reindex_required=True, reason="not a git repo")
+        if active.get("version", 1) < _VERSION:
+            return StaleSet(
+                full_reindex_required=True,
+                reason="metadata schema upgrade (v1 → v2)",
+            )
+        if active.get("embeddings_model") != self.embeddings.model_id:
+            return StaleSet(full_reindex_required=True, reason="embeddings_model changed")
+        if active.get("chunker_version") != self.chunker.version:
+            return StaleSet(full_reindex_required=True, reason="chunker_version changed")
+        if active.get("keyword_version") != self.keyword_index.version:
+            return StaleSet(full_reindex_required=True, reason="keyword_version changed")
+        if active.get("symbol_version") != self.symbol_index.version:
+            return StaleSet(full_reindex_required=True, reason="symbol_version changed")
+
+        prior_hashes: dict[str, str] = active.get("file_hashes") or {}
+        files = self.code_source.list_files(
+            self.repo_root, self.include_extensions, self.max_file_bytes
+        )
+        current_paths_rel: set[str] = set()
+        dirty: list[Path] = []
+        for f in files:
+            rel = f.relative_to(self.repo_root).as_posix()
+            current_paths_rel.add(rel)
+            try:
+                content = self.code_source.read(f)
+            except (OSError, UnicodeDecodeError):
+                # Unreadable now — skip; if it was indexed before, the next
+                # full reindex picks it up. Don't mark as dirty (avoids a
+                # poison-pill loop where a permanently-broken file forces
+                # repeated incremental runs).
+                continue
+            sha = hashlib.sha256(content.encode("utf-8")).hexdigest()
+            if prior_hashes.get(rel) != sha:
+                dirty.append(f)
+
+        deleted = tuple(p for p in prior_hashes if p not in current_paths_rel)
+
+        return StaleSet(
+            full_reindex_required=False,
+            reason=f"{len(dirty)} dirty, {len(deleted)} deleted",
+            dirty_files=tuple(dirty),
+            deleted_files=deleted,
+        )
+
+    def is_stale(self) -> bool:
+        """Thin wrapper kept so existing CLI / composition callers work.
+
+        Returns True when dirty_set's verdict is anything other than
+        the steady-state "no work". Sprint 6 retired the head_sha
+        global invalidator: changing HEAD without modifying any indexed
+        file no longer triggers a reindex (per-file SHA tracks content
+        truth, not commit position).
+        """
+        s = self.dirty_set()
+        return s.full_reindex_required or bool(s.dirty_files) or bool(s.deleted_files)
+
+    def run_incremental(self, stale: StaleSet) -> Path:
+        """Re-embed dirty files; purge deleted files; persist a new index dir.
+
+        Caller (composition root) is responsible for the atomic swap of
+        current.json after this returns — same contract as run().
+
+        When `stale.full_reindex_required` is True, falls back to
+        `self.run()` (the file lists are advisory in that mode).
+        Otherwise:
+        1. Loads the active index into the three stores. Mutations stay
+           in-memory (the SQLite adapters' load() copies disk → :memory:
+           specifically so this step is safe).
+        2. Drops every row whose path is in `stale.deleted_files`.
+        3. For each path in `stale.dirty_files`: drops its old rows from
+           every store, then re-chunks + re-embeds + re-extracts symbols
+           from the current content.
+        4. Persists every store to a fresh index dir.
+        5. Stamps metadata: file_hashes copied forward from the prior
+           run, with deletes removed and dirties updated. n_files derives
+           from len(file_hashes) so the count stays honest.
+        """
+        if stale.full_reindex_required:
+            return self.run()
+
+        active = self.current_index_dir()
+        prior = self._current_metadata()
+        if active is None or prior is None:
+            return self.run()
+
+        log.info("indexer-incremental: %s", stale.reason)
+
+        self.vector_store.load(active)
+        self.keyword_index.load(active)
+        self.symbol_index.load(active)
+
+        for path in stale.deleted_files:
+            self.vector_store.delete_by_path(path)
+            self.keyword_index.delete_by_path(path)
+            self.symbol_index.delete_by_path(path)
+
+        new_file_hashes: dict[str, str] = dict(prior.get("file_hashes") or {})
+        for path in stale.deleted_files:
+            new_file_hashes.pop(path, None)
+
+        new_chunks: list = []
+        new_defs: list[SymbolDef] = []
+        for f in stale.dirty_files:
+            rel = f.relative_to(self.repo_root).as_posix()
+            self.vector_store.delete_by_path(rel)
+            self.keyword_index.delete_by_path(rel)
+            self.symbol_index.delete_by_path(rel)
+            try:
+                content = self.code_source.read(f)
+            except (OSError, UnicodeDecodeError) as exc:
+                log.warning("indexer-incremental: skipping %s (%s)", rel, exc)
+                new_file_hashes.pop(rel, None)
+                continue
+            new_file_hashes[rel] = hashlib.sha256(content.encode("utf-8")).hexdigest()
+            for chunk in self.chunker.chunk(content, rel):
+                new_chunks.append(chunk)
+            extractor = getattr(self.chunker, "extract_definitions", None)
+            if extractor is not None:
+                try:
+                    new_defs.extend(extractor(content, rel))
+                except Exception as exc:  # noqa: BLE001 - same policy as run()
+                    log.warning(
+                        "indexer-incremental: symbol extract failed for %s (%s)",
+                        rel,
+                        exc,
+                    )
+
+        new_entries: list[IndexEntry] = []
+        for i in range(0, len(new_chunks), _BATCH_SIZE):
+            batch = new_chunks[i : i + _BATCH_SIZE]
+            vectors = self.embeddings.embed([c.snippet for c in batch])
+            for chunk, vec in zip(batch, vectors, strict=True):
+                new_entries.append(IndexEntry(chunk=chunk, vector=vec))
+
+        self.vector_store.add(new_entries)
+        self.keyword_index.add(new_entries)
+        self.symbol_index.add_definitions(new_defs)
+        ref_rows = [(c.path, c.line_start, c.snippet) for c in new_chunks]
+        self.symbol_index.add_references(ref_rows)
+
+        head = self.git_source.head_sha(self.repo_root) or "no-git"
+        new_dir_name = f"index-{head[:12]}-{datetime.now(UTC).strftime('%Y%m%dT%H%M%S%f')}"
+        new_dir = self.cache_dir / new_dir_name
+        new_dir.mkdir(parents=True, exist_ok=True)
+
+        self.vector_store.persist(new_dir)
+        self.keyword_index.persist(new_dir)
+        self.symbol_index.persist(new_dir)
+
+        meta = {
+            "version": _VERSION,
+            "head_sha": head,
+            "indexed_at": datetime.now(UTC).isoformat(),
+            "embeddings_model": self.embeddings.model_id,
+            "embeddings_dimension": self.embeddings.dimension,
+            "chunker_version": self.chunker.version,
+            "keyword_version": self.keyword_index.version,
+            "symbol_version": self.symbol_index.version,
+            # n_chunks here only counts what changed in this run; the
+            # store's true total is opaque from the use case's vantage
+            # point. Sprint 7 can wire a richer accounting if needed.
+            "n_chunks_added": len(new_entries),
+            "n_files": len(new_file_hashes),
+            "file_hashes": new_file_hashes,
+        }
+        (new_dir / "metadata.json").write_text(json.dumps(meta, indent=2))
+
+        return new_dir
+
+    def run(self) -> Path:
+        """Full reindex. Returns the new index directory path.
+
+        Caller (composition root) is responsible for the atomic swap of
+        current.json after this returns.
+        """
+        files = self.code_source.list_files(
+            self.repo_root, self.include_extensions, self.max_file_bytes
+        )
+        log.info("indexer: reindexing %d files", len(files))
+
+        all_entries: list[IndexEntry] = []
+        all_defs: list[SymbolDef] = []
+        # Collect chunks first so we can batch-embed.
+        chunks_with_paths: list = []
+        # Per-file SHA stamped into metadata so dirty_set() has a baseline
+        # for the next run. Computed inline so we don't re-read every file.
+        file_hashes: dict[str, str] = {}
+        for f in files:
+            try:
+                content = self.code_source.read(f)
+            except (OSError, UnicodeDecodeError) as exc:
+                log.warning("indexer: skipping %s (%s)", f, exc)
+                continue
+            rel = f.relative_to(self.repo_root).as_posix()
+            file_hashes[rel] = hashlib.sha256(content.encode("utf-8")).hexdigest()
+            for chunk in self.chunker.chunk(content, rel):
+                chunks_with_paths.append(chunk)
+            # Symbol extraction — only chunkers that expose it (TreeSitterChunker).
+            extractor = getattr(self.chunker, "extract_definitions", None)
+            if extractor is not None:
+                try:
+                    all_defs.extend(extractor(content, rel))
+                except Exception as exc:  # noqa: BLE001 - extractor failure must not abort indexing
+                    log.warning("indexer: symbol extract failed for %s (%s)", rel, exc)
+
+        # Batch-embed.
+        for i in range(0, len(chunks_with_paths), _BATCH_SIZE):
+            batch = chunks_with_paths[i : i + _BATCH_SIZE]
+            vectors = self.embeddings.embed([c.snippet for c in batch])
+            for chunk, vec in zip(batch, vectors, strict=True):
+                all_entries.append(IndexEntry(chunk=chunk, vector=vec))
+
+        # Reset and add.
+        head = self.git_source.head_sha(self.repo_root) or "no-git"
+        new_dir_name = f"index-{head[:12]}-{datetime.now(UTC).strftime('%Y%m%dT%H%M%S%f')}"
+        new_dir = self.cache_dir / new_dir_name
+        new_dir.mkdir(parents=True, exist_ok=True)
+
+        self.vector_store.add(all_entries)
+        self.vector_store.persist(new_dir)
+
+        self.keyword_index.add(all_entries)
+        self.keyword_index.persist(new_dir)
+
+        self.symbol_index.add_definitions(all_defs)
+        # Feed chunk snippets to the references FTS5 table so find_references
+        # has rows to match against (definitions alone are not enough — a
+        # symbol's call sites live in the chunk text, not in the defs table).
+        ref_rows = [(c.path, c.line_start, c.snippet) for c in chunks_with_paths]
+        self.symbol_index.add_references(ref_rows)
+        self.symbol_index.persist(new_dir)
+
+        meta = {
+            "version": _VERSION,
+            "head_sha": head,
+            "indexed_at": datetime.now(UTC).isoformat(),
+            "embeddings_model": self.embeddings.model_id,
+            "embeddings_dimension": self.embeddings.dimension,
+            "chunker_version": self.chunker.version,
+            "keyword_version": self.keyword_index.version,
+            "symbol_version": self.symbol_index.version,
+            "n_chunks": len(all_entries),
+            "n_files": len(file_hashes),
+            "file_hashes": file_hashes,
+        }
+        (new_dir / "metadata.json").write_text(json.dumps(meta, indent=2))
+
+        return new_dir
+
+    def current_index_dir(self) -> Path | None:
+        current = self._read_current()
+        if current is None:
+            return None
+        return self.cache_dir / current["active"]
+
+    # ---------- internal ----------
+
+    def _read_current(self) -> dict | None:
+        cur = self.cache_dir / _CURRENT_FILE
+        if not cur.exists():
+            return None
+        return json.loads(cur.read_text())
+
+    def _current_metadata(self) -> dict | None:
+        cur = self._read_current()
+        if cur is None:
+            return None
+        meta_path = self.cache_dir / cur["active"] / "metadata.json"
+        if not meta_path.exists():
+            return None
+        return json.loads(meta_path.read_text())

code_context/domain/use_cases/recent_changes.py

@@ -0,0 +1,36 @@
+"""RecentChangesUseCase — direct delegation to GitSource with no-repo fallback."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+from code_context.domain.models import Change
+from code_context.domain.ports import GitSource
+
+log = logging.getLogger(__name__)
+
+_DEFAULT_LOOKBACK_DAYS = 7
+
+
+@dataclass
+class RecentChangesUseCase:
+    git_source: GitSource
+    repo_root: Path
+
+    def run(
+        self,
+        since: datetime | None = None,
+        paths: list[str] | None = None,
+        max_count: int = 20,
+    ) -> list[Change]:
+        if not self.git_source.is_repo(self.repo_root):
+            log.warning("recent_changes: %s is not a git repo; returning []", self.repo_root)
+            return []
+        if since is None:
+            since = datetime.now(UTC) - timedelta(days=_DEFAULT_LOOKBACK_DAYS)
+        return self.git_source.commits(
+            self.repo_root, since=since, paths=paths, max_count=max_count
+        )

code_context/domain/use_cases/search_repo.py

@@ -0,0 +1,131 @@
+"""SearchRepoUseCase — hybrid retrieval pipeline.
+
+vector + keyword are fused via Reciprocal Rank Fusion (RRF). If a
+reranker is supplied, it re-scores the fused top-N. Returns top_k
+SearchResults with the fused or reranked score.
+
+Sprint 7: optional `bus` + `reload_callback` give the use case a
+"stale-aware" mode. On each `.run()` call, if the bus' generation has
+advanced since the last reload, the callback fires (typically
+re-loading the vector / keyword / symbol stores from `current.json`'s
+new active dir) before serving the query. Implemented as a single
+int compare in the hot path; legacy callers (no bus, no callback)
+incur zero overhead.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from code_context.domain.index_bus import IndexUpdateBus
+from code_context.domain.models import IndexEntry, SearchResult
+from code_context.domain.ports import EmbeddingsProvider, KeywordIndex, Reranker, VectorStore
+
+_STRUCTURAL_RE = re.compile(
+    r"^\s*(def |class |function |func |fn |export |const |interface |type |struct )"
+)
+_WHY_MAX_LEN = 80
+# Bumped from 2 in v0.1.x — RRF benefits from a wider pool because
+# entries unique to one ranker still feed the fusion.
+_OVER_FETCH_MULTIPLIER = 3
+# Canonical Reciprocal Rank Fusion constant from the original paper.
+_RRF_K = 60
+
+
+@dataclass
+class SearchRepoUseCase:
+    embeddings: EmbeddingsProvider
+    vector_store: VectorStore
+    keyword_index: KeywordIndex
+    reranker: Reranker | None = None
+    bus: IndexUpdateBus | None = None
+    reload_callback: Callable[[], None] | None = None
+    # Initialized to -1 so the very first call (bus.generation == 0)
+    # also triggers a reload — covers the cold-start case where the
+    # bg indexer hasn't yet published a swap but the active index dir
+    # might already be on disk and unloaded.
+    _last_seen_generation: int = field(default=-1, init=False, repr=False)
+
+    def run(
+        self,
+        query: str,
+        top_k: int = 5,
+        scope: str | None = None,
+    ) -> list[SearchResult]:
+        self._reload_if_swapped()
+        pool = top_k * _OVER_FETCH_MULTIPLIER
+        # 1. vector
+        query_vec = self.embeddings.embed([query])[0]
+        v_hits = self.vector_store.search(query_vec, k=pool)
+        # 2. keyword
+        k_hits = self.keyword_index.search(query, k=pool)
+        # 3. fuse via RRF
+        fused = _rrf_fuse(v_hits, k_hits, k_constant=_RRF_K)
+        if scope:
+            fused = [(entry, score) for entry, score in fused if entry.chunk.path.startswith(scope)]
+        # 4. optional rerank on the top of the fused pool
+        if self.reranker is not None and fused:
+            rerank_pool = fused[:pool]  # re-score the whole over-fetched pool
+            fused = self.reranker.rerank(query, rerank_pool, k=top_k)
+        else:
+            fused = fused[:top_k]
+        return [self._to_result(e, s) for e, s in fused]
+
+    def _reload_if_swapped(self) -> None:
+        """Refresh in-memory store handles if the bg indexer published a
+        new index dir since our last call. No-op for legacy callers
+        (bus is None). Reload exceptions propagate up — better to fail
+        loud than silently serve stale results — and the failed reload
+        does NOT update `_last_seen_generation`, so the next call retries.
+        """
+        if self.bus is None or self.reload_callback is None:
+            return
+        gen = self.bus.generation
+        if gen == self._last_seen_generation:
+            return
+        self.reload_callback()
+        # Only mark as seen AFTER a successful reload, so a transient
+        # failure (e.g. disk hiccup) gets retried on the next query.
+        self._last_seen_generation = gen
+
+    @staticmethod
+    def _to_result(entry: IndexEntry, score: float) -> SearchResult:
+        return SearchResult(
+            path=entry.chunk.path,
+            lines=(entry.chunk.line_start, entry.chunk.line_end),
+            snippet=entry.chunk.snippet,
+            score=float(score),
+            why=_compute_why(entry.chunk.snippet),
+        )
+
+
+def _rrf_fuse(
+    a: list[tuple[IndexEntry, float]],
+    b: list[tuple[IndexEntry, float]],
+    k_constant: int = 60,
+) -> list[tuple[IndexEntry, float]]:
+    """Reciprocal Rank Fusion. Identifies entries by chunk.path + line range."""
+    scores: dict[tuple[str, int, int], float] = {}
+    entry_by_key: dict[tuple[str, int, int], IndexEntry] = {}
+    for hits in (a, b):
+        for rank, (entry, _) in enumerate(hits):
+            c = entry.chunk
+            key = (c.path, c.line_start, c.line_end)
+            scores[key] = scores.get(key, 0.0) + 1.0 / (k_constant + rank + 1)
+            entry_by_key.setdefault(key, entry)
+    items = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
+    return [(entry_by_key[key], score) for key, score in items]
+
+
+def _compute_why(snippet: str) -> str:
+    """Pick a one-line description from the snippet."""
+    for line in snippet.splitlines():
+        if _STRUCTURAL_RE.match(line):
+            return line.strip()[:_WHY_MAX_LEN]
+    for line in snippet.splitlines():
+        stripped = line.strip()
+        if stripped:
+            return stripped[:_WHY_MAX_LEN]
+    return ""

code_context/server.py

@@ -0,0 +1,151 @@
+"""code-context-server entry: composition root + MCP stdio runner.
+
+Sprint 7 changes the startup shape:
+
+- **Foreground**: build the runtime, fast-load whatever index exists
+  on disk (no synchronous reindex), register MCP tools, run stdio.
+  Total time on a previously-indexed repo: ~1 s (model load + npy +
+  2× sqlite-to-memory). On a cache-cold repo: <100 ms (the foreground
+  has nothing to load yet; first queries return empty until bg
+  finishes).
+- **Background**: a BackgroundIndexer daemon thread runs dirty_set +
+  run_incremental (or full reindex) and publishes swap events to the
+  IndexUpdateBus. SearchRepoUseCase reloads its store handles on the
+  next query after each swap, transparently.
+
+The user pays the cold-reindex cost only on first install (or after
+a model upgrade); ongoing edit cycles are sub-10 s and run while
+Claude is asking other questions.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+from code_context._background import BackgroundIndexer
+from code_context._composition import (
+    atomic_swap_current,
+    build_indexer_and_store,
+    build_use_cases,
+    ensure_index,
+    fast_load_existing_index,
+    make_reload_callback,
+    setup_logging,
+)
+from code_context._watcher import RepoWatcher
+from code_context.adapters.driving.mcp_server import register
+from code_context.config import Config, load_config
+from code_context.domain.index_bus import IndexUpdateBus
+
+log = logging.getLogger("code_context")
+
+
+async def _run_server(cfg: Config) -> None:
+    indexer, store, embeddings, keyword_index, symbol_index = build_indexer_and_store(cfg)
+    bus = IndexUpdateBus()
+
+    # Foreground: load whatever index exists right now. No reindex. If the
+    # cache is empty, queries return [] until the bg thread finishes the
+    # first reindex; SearchRepoUseCase's bus-driven reload makes that
+    # transition transparent.
+    loaded = fast_load_existing_index(indexer, store, keyword_index, symbol_index)
+    if loaded:
+        log.info("loaded existing index from %s", indexer.current_index_dir())
+    elif not cfg.bg_reindex:
+        # Background reindex disabled (CC_BG_REINDEX=off) AND no index on
+        # disk. Fall back to the v0.7-style synchronous reindex so the
+        # server is functional after startup.
+        log.info("no existing index and bg_reindex=off; running synchronous reindex")
+        ensure_index(cfg, indexer, store, keyword_index, symbol_index)
+    else:
+        log.info(
+            "no existing index — first queries will return [] until the "
+            "background reindex finishes (~%d s on a typical repo)",
+            60,
+        )
+
+    reload_cb = make_reload_callback(indexer, store, keyword_index, symbol_index)
+    search, recent, summary, find_def, find_ref, file_tree, explain_diff = build_use_cases(
+        cfg,
+        indexer,
+        store,
+        embeddings,
+        keyword_index,
+        symbol_index,
+        bus=bus,
+        reload_callback=reload_cb,
+    )
+
+    bg = None
+    if cfg.bg_reindex:
+        bg = BackgroundIndexer(
+            indexer=indexer,
+            swap=lambda new_dir: atomic_swap_current(cfg, new_dir),
+            bus=bus,
+            idle_seconds=cfg.bg_idle_seconds,
+        )
+        bg.start()
+        bg.trigger()  # kick off initial dirty_set + (full or incremental) reindex
+        log.info("background indexer started (idle=%.2fs)", cfg.bg_idle_seconds)
+
+    watcher = None
+    if cfg.watch and bg is not None:
+        watcher = RepoWatcher(
+            root=cfg.repo_root,
+            on_change=bg.trigger,
+            debounce_ms=cfg.watch_debounce_ms,
+        )
+        watcher.start()
+        log.info(
+            "repo watcher armed (CC_WATCH=on, debounce=%dms)",
+            cfg.watch_debounce_ms,
+        )
+    elif cfg.watch and bg is None:
+        log.warning(
+            "CC_WATCH=on requires CC_BG_REINDEX=on; watcher not started "
+            "(without the bg thread there's nothing to trigger)"
+        )
+
+    server = Server("code-context")
+    register(
+        server,
+        search_repo=search,
+        recent_changes=recent,
+        get_summary=summary,
+        find_definition=find_def,
+        find_references=find_ref,
+        get_file_tree=file_tree,
+        explain_diff=explain_diff,
+    )
+
+    try:
+        async with stdio_server() as (read_stream, write_stream):
+            await server.run(read_stream, write_stream, server.create_initialization_options())
+    finally:
+        if watcher is not None:
+            log.info("stopping repo watcher")
+            watcher.stop()
+        if bg is not None:
+            log.info("stopping background indexer")
+            bg.stop(timeout=10.0)
+
+
+def main() -> int:
+    cfg = load_config()
+    setup_logging(cfg)
+    log.info("starting code-context-server (repo=%s)", cfg.repo_root)
+    try:
+        asyncio.run(_run_server(cfg))
+        return 0
+    except KeyboardInterrupt:
+        log.info("server interrupted; exiting")
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())