codecortex 0.2.1__tar.gz → 0.2.2__tar.gz

{codecortex-0.2.1/src/codecortex.egg-info → codecortex-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.2.1
+Version: 0.2.2
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -82,6 +82,16 @@ Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine
 
 The agent hands `result` straight to the model. If the graph backend isn't installed, the identical call returns `"result": null, "reason": "engine-unavailable"` — no exception, and the agent just falls back to its own search.
 
+## What makes it good
+
+- **Local-first and private.** One process on your machine — no cloud service, no API keys, no telemetry, no per-query network. Safe to point at a private repo, even with `--engine all`. (The one-time exception: `fastembed` downloads its embedding model once, then runs fully offline.)
+- **It never throws.** Every call returns the same JSON envelope; a missing or broken backend degrades to `null` *with a reason*. No exceptions, no 500s, no malformed output for the agent to trip over — so you never wrap `code.query` in a `try`.
+- **One tool, not three.** Register a single MCP server and it auto-routes each question to graph, LSP, or semantic — instead of wiring up three backends with three response shapes and three failure modes.
+- **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
+- **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
+- **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
+- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+
 ## Quickstart
 
 ```bash

{codecortex-0.2.1 → codecortex-0.2.2}/README.md

@@ -49,6 +49,16 @@ Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine
 
 The agent hands `result` straight to the model. If the graph backend isn't installed, the identical call returns `"result": null, "reason": "engine-unavailable"` — no exception, and the agent just falls back to its own search.
 
+## What makes it good
+
+- **Local-first and private.** One process on your machine — no cloud service, no API keys, no telemetry, no per-query network. Safe to point at a private repo, even with `--engine all`. (The one-time exception: `fastembed` downloads its embedding model once, then runs fully offline.)
+- **It never throws.** Every call returns the same JSON envelope; a missing or broken backend degrades to `null` *with a reason*. No exceptions, no 500s, no malformed output for the agent to trip over — so you never wrap `code.query` in a `try`.
+- **One tool, not three.** Register a single MCP server and it auto-routes each question to graph, LSP, or semantic — instead of wiring up three backends with three response shapes and three failure modes.
+- **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
+- **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
+- **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
+- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+
 ## Quickstart
 
 ```bash

{codecortex-0.2.1 → codecortex-0.2.2/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.2.1
+Version: 0.2.2
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -82,6 +82,16 @@ Pin one engine with `--engine graph│lsp│semantic`, or fan out with `--engine
 
 The agent hands `result` straight to the model. If the graph backend isn't installed, the identical call returns `"result": null, "reason": "engine-unavailable"` — no exception, and the agent just falls back to its own search.
 
+## What makes it good
+
+- **Local-first and private.** One process on your machine — no cloud service, no API keys, no telemetry, no per-query network. Safe to point at a private repo, even with `--engine all`. (The one-time exception: `fastembed` downloads its embedding model once, then runs fully offline.)
+- **It never throws.** Every call returns the same JSON envelope; a missing or broken backend degrades to `null` *with a reason*. No exceptions, no 500s, no malformed output for the agent to trip over — so you never wrap `code.query` in a `try`.
+- **One tool, not three.** Register a single MCP server and it auto-routes each question to graph, LSP, or semantic — instead of wiring up three backends with three response shapes and three failure modes.
+- **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
+- **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
+- **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
+- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+
 ## Quickstart
 
 ```bash

{codecortex-0.2.1 → codecortex-0.2.2}/src/codecortex.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ src/codeintel/providers/graph.py
 src/codeintel/providers/lsp.py
 src/codeintel/providers/none.py
 src/codeintel/providers/semantic.py
+tests/test_cache.py
 tests/test_doctor.py
 tests/test_e2e.py
 tests/test_gateway.py

codecortex-0.2.2/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

{codecortex-0.2.1 → codecortex-0.2.2}/src/codeintel/cache.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import os
 import threading
+from collections import OrderedDict
 from typing import Optional
 
 from codeintel.provider import Result
@@ -22,10 +23,15 @@ def _compute_hash(target: str, project_root: str) -> str:
 
 
 class ContentHashCache:
-    def __init__(self) -> None:
+    # Bounded: the server builds ONE gateway and reuses it across every request, so an unbounded
+    # store would grow for the life of the process. Capped as an LRU — past _max_entries the
+    # least-recently-used entry is evicted. Sized generously; an agent session touches at most a
+    # few hundred distinct (op, target, engine, root) keys, each holding a small Result.
+    def __init__(self, max_entries: int = 1024) -> None:
         self._lock = threading.Lock()
-        # key → (content_hash, Result)
-        self._store: dict[tuple[str, str, str, str], tuple[str, Result]] = {}
+        self._max_entries = max(1, int(max_entries))
+        # key → (content_hash, Result); OrderedDict preserves insertion/access order for LRU.
+        self._store: "OrderedDict[tuple[str, str, str, str], tuple[str, Result]]" = OrderedDict()
 
     def get(
         self,
@@ -41,10 +47,14 @@ class ContentHashCache:
         if entry is None:
             return None
         stored_hash, result = entry
+        # _compute_hash may read the target file — keep it OUTSIDE the lock (original intent).
         current_hash = f"{_compute_hash(target, project_root)}:{freshness}"
-        if current_hash == stored_hash:
-            return result
-        return None
+        if current_hash != stored_hash:
+            return None
+        with self._lock:
+            if key in self._store:  # may have been evicted between the two locked sections
+                self._store.move_to_end(key)  # mark most-recently-used
+        return result
 
     def put(
         self,
@@ -64,3 +74,6 @@ class ContentHashCache:
         content_hash = f"{_compute_hash(target, project_root)}:{freshness}"
         with self._lock:
             self._store[key] = (content_hash, result)
+            self._store.move_to_end(key)  # most-recently-used
+            while len(self._store) > self._max_entries:
+                self._store.popitem(last=False)  # evict least-recently-used

{codecortex-0.2.1 → codecortex-0.2.2}/src/codeintel/http_server.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 import sys
-from http.server import BaseHTTPRequestHandler, HTTPServer
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 from codeintel.server import code_doctor_handler, code_query_handler, code_status_handler
 
@@ -57,8 +57,12 @@ class _Handler(BaseHTTPRequestHandler):
         self._send_json(200, result)
 
 
-class CodeIntelHTTPServer(HTTPServer):
-    pass
+class CodeIntelHTTPServer(ThreadingHTTPServer):
+    # Threaded so one slow request (e.g. an LSP session warming, or a first-time index) can't
+    # block every other agent's query. The gateway is a shared singleton, but its mutable state
+    # is lock-guarded (query cache, reindexer, LSP sessions, graph project cache) and the
+    # semantic engine is thread-confined with WAL, so concurrent requests are safe.
+    daemon_threads = True
 
 
 _LOOPBACK_NAMES = {"localhost"}

{codecortex-0.2.1 → codecortex-0.2.2}/src/codeintel/providers/graph.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import shutil
 import subprocess
+import threading
 import time
 from typing import Any, Optional
 
@@ -35,6 +36,7 @@ class GraphProvider:
 
     def __init__(self) -> None:
         self._project_cache: dict[str, Optional[str]] = {}
+        self._project_cache_lock = threading.Lock()  # concurrent HTTP requests share one provider
         self._detect_backend()
 
     def _detect_backend(self) -> None:
@@ -125,11 +127,16 @@ class GraphProvider:
         return exact if exact is not None else best_prefix_name
 
     def _resolve_project(self, project_root: str) -> Optional[str]:
-        if project_root in self._project_cache:
-            return self._project_cache[project_root]
+        with self._project_cache_lock:
+            if project_root in self._project_cache:
+                return self._project_cache[project_root]
+        # list_projects shells out — resolve it OUTSIDE the lock so a slow backend can't serialize
+        # every concurrent request. A rare duplicate lookup on first contact is harmless (the
+        # result is idempotent); we simply never hold the lock across a subprocess.
         raw = self._run("list_projects", {}, 3000)
         name = self._match_project(raw, project_root)
-        self._project_cache[project_root] = name
+        with self._project_cache_lock:
+            self._project_cache[project_root] = name
         return name
 
     def probe(self, project_root: str, timeout_ms: int = 3000) -> dict:

codecortex-0.2.2/tests/test_cache.py

@@ -0,0 +1,61 @@
+"""Unit tests for ContentHashCache — the LRU bound added in 0.2.2 so the long-lived server
+can't grow the query cache without limit. Real cache object, no mocks."""
+from __future__ import annotations
+
+from codeintel.cache import ContentHashCache
+
+
+def _result(tag: str) -> dict:
+    return {"ok": True, "op": "search", "target": tag, "result": f"r-{tag}",
+            "engine": "semantic", "cached": False}
+
+
+def _put(cache: ContentHashCache, tag: str) -> None:
+    cache.put("search", tag, "semantic", "", _result(tag), 0)
+
+
+def _get(cache: ContentHashCache, tag: str):
+    return cache.get("search", tag, "semantic", "", 0)
+
+
+def test_hit_returns_stored_result():
+    c = ContentHashCache()
+    _put(c, "x")
+    got = _get(c, "x")
+    assert got is not None and got["result"] == "r-x"
+
+
+def test_freshness_bump_busts_the_entry():
+    c = ContentHashCache()
+    _put(c, "x")                                   # stored at freshness 0
+    assert c.get("search", "x", "semantic", "", 1) is None  # a completed reindex invalidates it
+
+
+def test_null_result_is_not_cached():
+    c = ContentHashCache()
+    c.put("search", "x", "semantic", "", {"ok": True, "result": None}, 0)
+    assert _get(c, "x") is None
+
+
+def test_evicts_least_recently_used_past_capacity():
+    c = ContentHashCache(max_entries=3)
+    for t in ("t0", "t1", "t2"):
+        _put(c, t)
+    # Touch t0 so it becomes most-recently-used; t1 is now the LRU.
+    assert _get(c, "t0") is not None
+    _put(c, "t3")  # over capacity → evict the LRU (t1)
+
+    assert _get(c, "t1") is None       # evicted
+    assert _get(c, "t0") is not None   # kept — it was accessed most recently
+    assert _get(c, "t2") is not None   # kept
+    assert _get(c, "t3") is not None   # just inserted
+
+
+def test_capacity_is_never_exceeded():
+    c = ContentHashCache(max_entries=5)
+    for i in range(50):
+        _put(c, f"k{i}")
+    assert len(c._store) == 5
+    # The 5 most recent survive; older keys are gone.
+    assert _get(c, "k49") is not None
+    assert _get(c, "k0") is None

codecortex-0.2.1/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.1"