codebrain 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

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.3.4"
+    __version__ = "0.3.5"

codebrain/graph/store.py

@@ -113,6 +113,11 @@ class GraphStore:
         ).fetchone()
         return row["content_hash"] if row else None
 
+    def all_file_paths(self) -> list[str]:
+        """Return every file path currently in the index."""
+        rows = self.conn.execute("SELECT path FROM files").fetchall()
+        return [row["path"] for row in rows]
+
     # ------------------------------------------------------------------
     # Node operations
     # ------------------------------------------------------------------

codebrain/mcp_lifecycle.py

@@ -167,7 +167,7 @@ def _remove_pid_file(pid_file: Path) -> None:
         pass
 
 
-def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
+def _find_watch_target(start_pid: int) -> tuple[int, float | None, bool]:
     """Pick the PID whose death should kill the MCP.
 
     Walks up the ancestor chain (up to ANCESTOR_WALK_DEPTH levels) looking
@@ -175,6 +175,10 @@ def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
     real IDE host. Falls back to ``start_pid`` if no hint matches, psutil
     is unavailable, or ``CODEBRAIN_MCP_DISABLE_ANCESTOR_WALK=1`` is set.
 
+    Returns ``(pid, create_time, host_anchored)``. ``host_anchored`` is True
+    only when an actual IDE host process was found — callers use it to decide
+    whether the idle-timeout backstop is needed at all.
+
     Why: on Windows, Claude Code spawns the MCP via a transient launcher
     (cmd.exe wrapper or Electron worker shell). The launcher exits soon
     after the python child starts, so watching ``os.getppid()`` directly
@@ -183,16 +187,16 @@ def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
     try:
         import psutil
     except ImportError:
-        return start_pid, None
+        return start_pid, None, False
 
     fallback_create_time: float | None = None
     try:
         fallback_create_time = psutil.Process(start_pid).create_time()
     except (psutil.NoSuchProcess, psutil.AccessDenied):
-        return start_pid, None
+        return start_pid, None, False
 
     if os.environ.get("CODEBRAIN_MCP_DISABLE_ANCESTOR_WALK") == "1":
-        return start_pid, fallback_create_time
+        return start_pid, fallback_create_time, False
 
     try:
         proc = psutil.Process(start_pid)
@@ -202,7 +206,7 @@ def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
             except (psutil.NoSuchProcess, psutil.AccessDenied):
                 break
             if any(hint in name for hint in HOST_PROCESS_NAME_HINTS):
-                return proc.pid, proc.create_time()
+                return proc.pid, proc.create_time(), True
             try:
                 parent = proc.parent()
             except (psutil.NoSuchProcess, psutil.AccessDenied):
@@ -212,7 +216,7 @@ def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
             proc = parent
     except (psutil.NoSuchProcess, psutil.AccessDenied):
         pass
-    return start_pid, fallback_create_time
+    return start_pid, fallback_create_time, False
 
 
 def _parent_watchdog(initial_ppid: int, initial_create_time: float | None) -> None:
@@ -241,16 +245,35 @@ def _parent_watchdog(initial_ppid: int, initial_create_time: float | None) -> No
             _log.debug("parent watchdog tick error: %s", exc)
 
 
-def _idle_watchdog() -> None:
-    if IDLE_TIMEOUT_SECONDS <= 0:
+def _effective_idle_timeout(host_anchored: bool) -> int:
+    """Resolve the idle timeout in seconds (0 disables the idle watchdog).
+
+    The idle watchdog is a *backstop* for when the parent watchdog has no
+    reliable IDE host to watch. When we are anchored to a real host
+    (claude/cursor/vscode), the parent watchdog deterministically tears the
+    server down at session end — an idle timeout on top of that only kills
+    the file watcher mid-session and leaves the index stale. So:
+
+    - explicit ``CODEBRAIN_MCP_IDLE_TIMEOUT`` env var always wins
+    - otherwise: disabled when host-anchored, 30-min backstop when not
+    """
+    if "CODEBRAIN_MCP_IDLE_TIMEOUT" in os.environ:
+        return IDLE_TIMEOUT_SECONDS
+    if host_anchored:
+        return 0
+    return IDLE_TIMEOUT_SECONDS
+
+
+def _idle_watchdog(timeout: int) -> None:
+    if timeout <= 0:
         return
-    poll = max(5, min(60, IDLE_TIMEOUT_SECONDS // 4))
+    poll = max(5, min(60, timeout // 4))
     while True:
         time.sleep(poll)
         with _last_activity_lock:
             idle = time.time() - _last_activity
-        if idle > IDLE_TIMEOUT_SECONDS:
-            _exit(f"idle for {idle:.0f}s (limit {IDLE_TIMEOUT_SECONDS}s)")
+        if idle > timeout:
+            _exit(f"idle for {idle:.0f}s (limit {timeout}s)")
 
 
 def _lifetime_watchdog(start: float) -> None:
@@ -285,13 +308,16 @@ def install_watchdogs(repo_root: Path | None = None) -> None:
         atexit.register(_remove_pid_file, pid_file)
 
     immediate_ppid = os.getppid()
-    initial_ppid, initial_create_time = _find_watch_target(immediate_ppid)
+    initial_ppid, initial_create_time, host_anchored = _find_watch_target(immediate_ppid)
+    idle_timeout = _effective_idle_timeout(host_anchored)
 
     _log.info(
-        "MCP watchdogs installed (ppid=%d via=%d, idle_timeout=%ds, max_lifetime=%ds)",
+        "MCP watchdogs installed (ppid=%d via=%d, host_anchored=%s, "
+        "idle_timeout=%ds, max_lifetime=%ds)",
         initial_ppid,
         immediate_ppid,
-        IDLE_TIMEOUT_SECONDS,
+        host_anchored,
+        idle_timeout,
         MAX_LIFETIME_SECONDS,
     )
 
@@ -303,6 +329,7 @@ def install_watchdogs(repo_root: Path | None = None) -> None:
     ).start()
     threading.Thread(
         target=_idle_watchdog,
+        args=(idle_timeout,),
         name="cb-idle-watchdog",
         daemon=True,
     ).start()

codebrain/watcher/file_watcher.py

@@ -11,9 +11,10 @@ from watchdog.observers import Observer
 
 from codebrain.config import INDEXABLE_EXTENSIONS, WATCHER_DEBOUNCE_SECONDS
 from codebrain.graph.store import GraphStore
-from codebrain.indexer import incremental_update
+from codebrain.indexer import discover_files, incremental_update
+from codebrain.utils import normalize_path
 from codebrain.logging import get_logger
-from codebrain.settings import load_settings
+from codebrain.settings import Settings, load_settings
 
 _log = get_logger("watcher")
 
@@ -37,6 +38,8 @@ class _DebouncedHandler(FileSystemEventHandler):
         self._changed: set[Path] = set()
         self._deleted: set[Path] = set()
         self._lock = threading.Lock()
+        # Serializes DB writes between flush timer threads and the catch-up thread.
+        self.db_lock = threading.Lock()
         self._timer: threading.Timer | None = None
         self._last_validation: dict[str, object] = {}  # rel_path -> ValidationReport
 
@@ -57,6 +60,14 @@ class _DebouncedHandler(FileSystemEventHandler):
         if not changed and not deleted:
             return
 
+        # Live file edits count as activity — without this the idle watchdog
+        # kills the MCP (and this watcher with it) mid-editing-session.
+        try:
+            from codebrain.mcp_lifecycle import mark_activity
+            mark_activity()
+        except Exception:
+            pass
+
         # Redirect stdout to stderr to prevent MCP stdio protocol corruption
         # when running inside the MCP server process.
         import sys
@@ -67,7 +78,8 @@ class _DebouncedHandler(FileSystemEventHandler):
             if changed:
                 self._validate_changed(changed)
 
-            result = incremental_update(self.repo_root, changed, deleted, self.store)
+            with self.db_lock:
+                result = incremental_update(self.repo_root, changed, deleted, self.store)
             total = result["files_updated"] + result["files_removed"]
             if total:
                 _log.info(
@@ -147,6 +159,59 @@ class _DebouncedHandler(FileSystemEventHandler):
         self._schedule_flush()
 
 
+def catch_up_sync(
+    repo_root: Path,
+    store: GraphStore,
+    settings: Settings | None = None,
+    db_lock: threading.Lock | None = None,
+) -> dict:
+    """Bring the index up to date with changes made while no watcher was alive.
+
+    The file watcher only sees events that happen while its process is
+    running. Edits made between sessions (or after a lifecycle watchdog
+    killed the MCP server) are otherwise missed forever, leaving the index
+    stale until a manual `brain reindex`. This diffs disk vs. index:
+
+    - changed/new files: detected by content hash inside incremental_update
+    - deleted files: indexed paths that no longer exist on disk
+
+    Returns the incremental_update summary dict.
+    """
+    on_disk = discover_files(repo_root, settings)
+    disk_rels = {normalize_path(p, repo_root) for p in on_disk}
+    deleted = [
+        repo_root / rel
+        for rel in store.all_file_paths()
+        if rel not in disk_rels
+    ]
+    lock = db_lock if db_lock is not None else threading.Lock()
+    with lock:
+        result = incremental_update(repo_root, on_disk, deleted, store)
+    if result["files_updated"] or result["files_removed"]:
+        _log.info(
+            "Catch-up sync: updated %d, removed %d (%.3fs)",
+            result["files_updated"],
+            result["files_removed"],
+            result["elapsed_seconds"],
+        )
+    else:
+        _log.info("Catch-up sync: index already current")
+    return result
+
+
+def _catch_up_in_background(
+    repo_root: Path, store: GraphStore, settings: Settings, handler: _DebouncedHandler,
+) -> None:
+    # NOTE: deliberately no sys.stdout redirect here — this thread runs
+    # concurrently with the MCP initialize handshake on the real stdout;
+    # swapping the global stdout would corrupt the JSON-RPC stream.
+    # Parsers do not print, so there is nothing to redirect anyway.
+    try:
+        catch_up_sync(repo_root, store, settings, db_lock=handler.db_lock)
+    except Exception as exc:
+        _log.warning("Catch-up sync failed: %s", exc)
+
+
 def start_watching_background(
     repo_root: Path, db_path: Path,
 ) -> tuple[Observer, GraphStore, _DebouncedHandler]:
@@ -166,7 +231,15 @@ def start_watching_background(
     observer = Observer()
     observer.daemon = True
     observer.schedule(handler, str(repo_root), recursive=True)
+    # Observer starts BEFORE the catch-up scan so no event falls in the gap;
+    # the hash check in incremental_update makes any overlap harmless.
     observer.start()
+    threading.Thread(
+        target=_catch_up_in_background,
+        args=(repo_root, store, settings, handler),
+        name="cb-catchup-sync",
+        daemon=True,
+    ).start()
     _log.info("Background watcher started for %s", repo_root)
     return observer, store, handler
 

{codebrain-0.3.4.dist-info → codebrain-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebrain
-Version: 0.3.4
+Version: 0.3.5
 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.3.4.dist-info → codebrain-0.3.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-codebrain/__init__.py,sha256=-sDaW43PeyYkocMq06I_oQkqnC3tH_w3dnSmTgmUMuk,392
+codebrain/__init__.py,sha256=x27U2sCVt0bfIOA_zO8t7cwyzq-sFjkbLTNm-MpjHME,392
 codebrain/__main__.py,sha256=dgd9lRZovV1k1tScEW_wvPPjPEACXc-EcLtJ7AN3M48,115
 codebrain/agent_bridge.py,sha256=JDny3232R6rfFsQTWOoYygGgykx6rb8ektLRENPUcDQ,6262
 codebrain/analyzer.py,sha256=RxyajZp0E8XuB_1SkK1UEXD00gOo3e2vtBzS-US6ms8,40701
@@ -23,7 +23,7 @@ codebrain/kt.py,sha256=iXeHArPbSrrr2ObH4nuyXPobdBXSOR3b7JbIqXB0kj4,17199
 codebrain/kt_video.py,sha256=quaUyPUJh8xXsj52aBCPp_L8fekNC4vHmNYrUTfCqcE,29211
 codebrain/llm.py,sha256=0D5c5BJMVkLz2OoybfMxlUdJEbz16cZoNgVmm-LzFH0,25606
 codebrain/logging.py,sha256=ORR5L8REVlh4aJz9vqErmi76aqjLN2xVKoA2gSv_jas,1110
-codebrain/mcp_lifecycle.py,sha256=FzZBKk_MLUFC97TgT_M_EG0oNZgUAPZXzukm1U3LUKc,14172
+codebrain/mcp_lifecycle.py,sha256=fpwajl4-5YdZe0cEMmE2_o_FFkyrh3bl3Jqwrp-XGAM,15332
 codebrain/mcp_server.py,sha256=Lb5ob3NI-S0Ln7Yp8G8HxWsKvAuzVzl123N08ZkxPyw,110648
 codebrain/migration.py,sha256=ZMcug6OsvvK-DVdfmqhWCUx-oVj0KQD0EGlBVx6Jxvk,29489
 codebrain/modernize.py,sha256=4usRjIFONEThpYhemLIjoYXb9ohEbO7j2wzVO15Dz5A,38525
@@ -48,7 +48,7 @@ codebrain/actions/test_gen.py,sha256=PAnHfYuLp-AIF4YrQYQaBH5ADWhCqUVEI7bFDquxPjs
 codebrain/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codebrain/graph/query.py,sha256=FdkWTIKteCdAGnal01LJDuoSXzSpNp3AT9e0AH-m1eg,44131
 codebrain/graph/schema.py,sha256=5PItrNUMQt37kTsL3SUVLPB7rP2JtQXx-Y4uxX0A0H0,6521
-codebrain/graph/store.py,sha256=eFgXCor-MV-H897s8tcnNOeOiRieOoBmh70sj1Xi3NM,15717
+codebrain/graph/store.py,sha256=pqJu7c6krXgBYDQ5e-KZ8nHWVvNU4OeeXVtDVSNY7pI,15937
 codebrain/memory/__init__.py,sha256=PuFR35m1GPIbRAuUxKu4JYBDlPXJWMPbyrWiggFT2sU,158
 codebrain/memory/store.py,sha256=W31fe4aNTkdi-Woe8bZ8SZ9aUHpWrfBkb-9dQs0geyI,9394
 codebrain/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -73,10 +73,10 @@ codebrain/parser/typescript_parser.py,sha256=fi0DoXLCi_L0aQzpadumDpFHaSyekfp3wmV
 codebrain/parser/typescript_treesitter.py,sha256=7RTdcA-HTgrlRhEMwSGa-63saNcjqtPiKZYrEOBmlD4,26391
 codebrain/parser/vue_parser.py,sha256=ZWtjUOyItn_SNfvD6T8j7alV4aIfcHA94WDCS5P59Ps,13054
 codebrain/watcher/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codebrain/watcher/file_watcher.py,sha256=EUXQ5L8gutOCvGgtNZ9wMt6RL74wA6snH7vnDnxm13A,6562
-codebrain-0.3.4.dist-info/licenses/LICENSE,sha256=Dxb0L3H90lGFFik90WQXfMkM_8utGA1BDqizqdCT3UE,1079
-codebrain-0.3.4.dist-info/METADATA,sha256=zPvG0VbV4DwOg8h9au3Zsnpzr8upsFVbzYuRcYpVSRI,10129
-codebrain-0.3.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codebrain-0.3.4.dist-info/entry_points.txt,sha256=FHKSyI7le7GK78HxAKQK54-yzt-yHNxX0df3VpGC5wg,44
-codebrain-0.3.4.dist-info/top_level.txt,sha256=mUxCZc80EyNOMzd2vAm22uIhnOb1Aw7ZOAUT_u-ksx4,10
-codebrain-0.3.4.dist-info/RECORD,,
+codebrain/watcher/file_watcher.py,sha256=6x-fWIP5YBuwq5BCX6HOV-Kc8EVgE4JUoeLxYJtxDf0,9454
+codebrain-0.3.5.dist-info/licenses/LICENSE,sha256=Dxb0L3H90lGFFik90WQXfMkM_8utGA1BDqizqdCT3UE,1079
+codebrain-0.3.5.dist-info/METADATA,sha256=As_yyzhW3AO24DXeNzezMPpyvNb8HYb8G6LhrtVUIGs,10129
+codebrain-0.3.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codebrain-0.3.5.dist-info/entry_points.txt,sha256=FHKSyI7le7GK78HxAKQK54-yzt-yHNxX0df3VpGC5wg,44
+codebrain-0.3.5.dist-info/top_level.txt,sha256=mUxCZc80EyNOMzd2vAm22uIhnOb1Aw7ZOAUT_u-ksx4,10
+codebrain-0.3.5.dist-info/RECORD,,