codebrain 0.4.0__tar.gz → 0.4.1__tar.gz

{codebrain-0.4.0 → codebrain-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebrain
-Version: 0.4.0
+Version: 0.4.1
 Summary: Know what breaks before you break it. Structural knowledge graph for codebases — impact analysis, dead code detection, health scores. No LLM required.
 Author: CodeBrain Contributors
 License: MIT License

{codebrain-0.4.0 → codebrain-0.4.1}/codebrain/__init__.py

@@ -7,4 +7,4 @@ try:
 except PackageNotFoundError:
     # Source checkout without installation (e.g. running from a worktree).
     # Keep in sync with [project.version] in pyproject.toml.
-    __version__ = "0.4.0"
+    __version__ = "0.4.1"

{codebrain-0.4.0 → codebrain-0.4.1}/codebrain/graph/store.py

@@ -102,6 +102,20 @@ class GraphStore:
             self.conn.execute("DELETE FROM nodes WHERE file_path = ?", (path,))
             self.conn.execute("DELETE FROM files WHERE path = ?", (path,))
 
+    def remove_files(self, paths: list[str]) -> None:
+        """Delete many files and their nodes/edges in ONE transaction.
+
+        Per-file transactions take minutes when thousands of rows go stale
+        (e.g. a venv that used to be indexed); this takes well under a second.
+        """
+        if not paths:
+            return
+        params = [(p,) for p in paths]
+        with self.conn:
+            self.conn.executemany("DELETE FROM edges WHERE file_path = ?", params)
+            self.conn.executemany("DELETE FROM nodes WHERE file_path = ?", params)
+            self.conn.executemany("DELETE FROM files WHERE path = ?", params)
+
     def clear_all(self) -> None:
         """Delete all data from the graph (files, nodes, edges).
 

{codebrain-0.4.0 → codebrain-0.4.1}/codebrain/indexer.py

@@ -542,10 +542,9 @@ def incremental_update(
     removed = 0
     errors: list[str] = []
 
-    for file_path in deleted_files:
-        rel = normalize_path(file_path, repo_root)
-        store.remove_file(rel)
-        removed += 1
+    deleted_rels = [normalize_path(fp, repo_root) for fp in deleted_files]
+    store.remove_files(deleted_rels)
+    removed = len(deleted_rels)
 
     # tree-sitter can hang holding the GIL on Windows — isolate those
     # extensions in a subprocess, same as full_index. A hang here would

{codebrain-0.4.0 → codebrain-0.4.1}/codebrain/mcp_server.py

@@ -124,10 +124,10 @@ def _make_store():
 import threading as _threading
 import time as _time
 
-FRESHNESS_INTERVAL_SECONDS = float(os.environ.get("CODEBRAIN_FRESHNESS_INTERVAL", "5"))
-# Above this many stale files, sync in the background instead of inline so a
-# huge drift (e.g. branch switch on a big repo) can't eat the tool deadline.
-FRESHNESS_INLINE_LIMIT = 200
+# Default 30s: the watcher handles live edits instantly; this gate is the
+# convergence safety net. Measured walk cost is ~2-5s on a midsize repo —
+# a 5s interval would burn most of a core just rescanning.
+FRESHNESS_INTERVAL_SECONDS = float(os.environ.get("CODEBRAIN_FRESHNESS_INTERVAL", "30"))
 
 _freshness_lock = _threading.Lock()
 _last_freshness_check: dict[str, float] = {}
@@ -157,10 +157,13 @@ _FRESHNESS_EXEMPT_TOOLS = frozenset({
 
 
 def _ensure_fresh() -> None:
-    """Best-effort staleness sync before serving a tool call.
+    """Schedule a background freshness sync if one is due.
 
-    Throttled per database; never blocks on a concurrent sync (a slightly
-    stale answer beats a deadlocked one); never raises.
+    NEVER does disk walks, hashing, or parsing on the tool path. v0.4.0
+    ran the staleness scan inline and on large or venv-polluted repos the
+    walk alone exceeded the tool deadline — every query timed out. The
+    contract is: tool calls never wait; the index converges within
+    seconds via the background worker (single-flight, throttled per DB).
     """
     if FRESHNESS_INTERVAL_SECONDS <= 0:
         return
@@ -172,10 +175,24 @@ def _ensure_fresh() -> None:
     now = _time.monotonic()
     if now - _last_freshness_check.get(key, 0.0) < FRESHNESS_INTERVAL_SECONDS:
         return
+    # Single-flight: the lock is held for the WHOLE background operation
+    # and released by the worker. Without this, slow syncs pile up — a
+    # repo with thousands of stale rows spawned a new mega-sync every
+    # interval while the first was still running.
     if not _freshness_lock.acquire(blocking=False):
-        return  # another sync in flight — serve what we have
+        return  # a sync is already in flight
+    _last_freshness_check[key] = now
+    _threading.Thread(
+        target=_freshness_worker,
+        args=(db_path,),
+        name="cb-freshness-sync",
+        daemon=True,
+    ).start()
+
+
+def _freshness_worker(db_path: Path) -> None:
+    """Owns _freshness_lock; scans and syncs, then releases."""
     try:
-        _last_freshness_check[key] = now
         from codebrain.graph.store import GraphStore
         from codebrain.indexer import incremental_update, scan_stale
 
@@ -184,22 +201,10 @@ def _ensure_fresh() -> None:
             changed, deleted = scan_stale(repo_root, store)
             if not changed and not deleted:
                 return
-            if len(changed) + len(deleted) > FRESHNESS_INLINE_LIMIT:
-                _log.info(
-                    "Freshness: %d files drifted — syncing in background",
-                    len(changed) + len(deleted),
-                )
-                _threading.Thread(
-                    target=_background_freshness_sync,
-                    args=(repo_root, db_path, changed, deleted),
-                    name="cb-freshness-sync",
-                    daemon=True,
-                ).start()
-                return
             result = incremental_update(repo_root, changed, deleted, store)
             if result["files_updated"] or result["files_removed"]:
                 _log.info(
-                    "Freshness: updated %d, removed %d (%.3fs)",
+                    "Freshness sync: updated %d, removed %d (%.3fs)",
                     result["files_updated"],
                     result["files_removed"],
                     result["elapsed_seconds"],
@@ -210,25 +215,6 @@ def _ensure_fresh() -> None:
         _freshness_lock.release()
 
 
-def _background_freshness_sync(
-    repo_root: Path, db_path: Path, changed: list, deleted: list,
-) -> None:
-    try:
-        from codebrain.graph.store import GraphStore
-        from codebrain.indexer import incremental_update
-
-        with GraphStore(db_path) as store:
-            result = incremental_update(repo_root, changed, deleted, store)
-        _log.info(
-            "Background freshness sync: updated %d, removed %d (%.3fs)",
-            result["files_updated"],
-            result["files_removed"],
-            result["elapsed_seconds"],
-        )
-    except Exception as exc:
-        _log.warning("Background freshness sync failed: %s", exc)
-
-
 def _safe_tool(fn):  # noqa: ANN001, ANN201
     """Wrap an MCP tool so it cooperates with MCP cancellation.
 

{codebrain-0.4.0 → codebrain-0.4.1}/codebrain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebrain
-Version: 0.4.0
+Version: 0.4.1
 Summary: Know what breaks before you break it. Structural knowledge graph for codebases — impact analysis, dead code detection, health scores. No LLM required.
 Author: CodeBrain Contributors
 License: MIT License

{codebrain-0.4.0 → codebrain-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codebrain"
-version = "0.4.0"
+version = "0.4.1"
 description = "Know what breaks before you break it. Structural knowledge graph for codebases — impact analysis, dead code detection, health scores. No LLM required."
 readme = "README.md"
 license = {file = "LICENSE"}

{codebrain-0.4.0 → codebrain-0.4.1}/tests/test_mcp_server.py

@@ -624,10 +624,20 @@ class TestMCPBadInput:
 
 
 class TestFreshnessOnRead:
-    """Index drift must be invisible at the tool boundary — answers reflect
-    current code regardless of which background watchers are alive."""
-
-    def test_tool_call_sees_offline_edit(self, mcp_project):
+    """Index drift converges at the tool boundary — answers reflect current
+    code within seconds regardless of which background watchers are alive,
+    and the tool path itself NEVER waits on disk work."""
+
+    def _wait_for(self, predicate, timeout=15.0):
+        import time
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if predicate():
+                return True
+            time.sleep(0.1)
+        return False
+
+    def test_tool_call_triggers_sync_of_offline_edit(self, mcp_project):
         import codebrain.mcp_server as ms
         repo_root, db_path = mcp_project
         ms._last_freshness_check.clear()
@@ -636,24 +646,62 @@ class TestFreshnessOnRead:
             "def hotfix_func():\n    return 1\n"
         )
         from codebrain.mcp_server import search_symbol
-        result = _run_async(search_symbol("hotfix_func"))
-        data = json.loads(result)
-        assert len(data) > 0, "freshness gate should have indexed the new file"
 
-    def test_throttle_skips_rescan_within_interval(self, mcp_project, monkeypatch):
+        def _found():
+            data = json.loads(_run_async(search_symbol("hotfix_func")))
+            return len(data) > 0
+
+        assert self._wait_for(_found), (
+            "freshness worker should have indexed the offline edit within seconds"
+        )
+
+    def test_tool_path_does_no_disk_scan_inline(self, mcp_project, monkeypatch):
+        """THE v0.4.0 regression: the staleness scan ran inline and on big
+        repos the walk alone blew the tool deadline. The tool path must
+        return without ever calling scan_stale in the calling thread."""
+        import threading
         import codebrain.indexer as idx
         import codebrain.mcp_server as ms
-        calls = []
+        scan_threads = []
         real = idx.scan_stale
         monkeypatch.setattr(
             idx, "scan_stale",
-            lambda *a, **k: (calls.append(1), real(*a, **k))[1],
+            lambda *a, **k: (scan_threads.append(threading.current_thread().name), real(*a, **k))[1],
         )
         ms._last_freshness_check.clear()
         from codebrain.mcp_server import search_symbol
         _run_async(search_symbol("process"))
+        self._wait_for(lambda: len(scan_threads) >= 1)
+        assert scan_threads, "freshness worker never ran"
+        for name in scan_threads:
+            assert name == "cb-freshness-sync", (
+                f"scan_stale ran on thread {name!r} — disk walks are forbidden "
+                "on the tool path"
+            )
+
+    def test_syncs_do_not_pile_up(self, mcp_project, monkeypatch):
+        """Single-flight: while one sync is in flight, new tool calls must
+        not spawn additional syncs (mega-syncs used to stack every 5s)."""
+        import time
+        import codebrain.indexer as idx
+        import codebrain.mcp_server as ms
+        calls = []
+
+        def slow_scan(*a, **k):
+            calls.append(1)
+            time.sleep(1.0)
+            return [], []
+
+        monkeypatch.setattr(idx, "scan_stale", slow_scan)
+        monkeypatch.setattr(ms, "FRESHNESS_INTERVAL_SECONDS", 0.01)
+        ms._last_freshness_check.clear()
+        from codebrain.mcp_server import search_symbol
         _run_async(search_symbol("process"))
-        assert len(calls) == 1, "second call within interval must not rescan"
+        time.sleep(0.1)  # worker now inside slow_scan
+        _run_async(search_symbol("process"))
+        _run_async(search_symbol("process"))
+        time.sleep(1.2)  # let the worker finish
+        assert len(calls) == 1, "concurrent syncs piled up"
 
     def test_validators_are_exempt(self):
         import codebrain.mcp_server as ms
@@ -661,3 +709,29 @@ class TestFreshnessOnRead:
         # freshness sync first would erase the baseline and kill the gate.
         for tool in ("validate_after_write", "validate_change", "propose_change"):
             assert tool in ms._FRESHNESS_EXEMPT_TOOLS
+
+
+class TestBatchedDeletion:
+    def test_thousands_of_stale_rows_removed_fast(self, tmp_path):
+        """Stale-row cleanup at venv scale must be sub-second, not minutes."""
+        import time
+        from codebrain.graph.store import GraphStore
+        from codebrain.indexer import incremental_update
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        db = repo / ".codebrain" / "graph.db"
+        with GraphStore(db) as store:
+            # Fabricate 5000 indexed files that no longer exist on disk
+            store.conn.executemany(
+                "INSERT INTO files (path, content_hash, last_indexed, line_count) "
+                "VALUES (?, 'x', 0, 1)",
+                [(f"stale/venv/mod_{i}.py",) for i in range(5000)],
+            )
+            store.conn.commit()
+            ghosts = [repo / f"stale/venv/mod_{i}.py" for i in range(5000)]
+            t0 = time.perf_counter()
+            result = incremental_update(repo, [], ghosts, store)
+            elapsed = time.perf_counter() - t0
+            assert result["files_removed"] == 5000
+            assert elapsed < 5.0, f"batched deletion took {elapsed:.1f}s"
+            assert store.all_file_paths() == []