codebrain 0.3.1__tar.gz → 0.3.3__tar.gz

{codebrain-0.3.1 → codebrain-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebrain
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -123,15 +123,17 @@ MCP config. Restart Claude Code and it has tools like
 `mcp__codebrain__ask_codebase`, plus a few dozen more. It uses them on
 its own.
 
-Manual config (any MCP-compatible client):
+Manual config — drop `.mcp.json` at **your project's root** (not in a
+global config). CodeBrain's index lives in `<repo>/.codebrain/`, so a
+global config would make every Claude session in every project fight
+over the same database. `brain setup` writes the right thing for you.
 
 ```json
 {
   "mcpServers": {
     "codebrain": {
       "command": "python",
-      "args": ["-m", "codebrain.mcp_server"],
-      "env": { "CODEBRAIN_PROJECT": "/absolute/path/to/repo" }
+      "args": ["-m", "codebrain.mcp_server"]
     }
   }
 }

{codebrain-0.3.1 → codebrain-0.3.3}/README.md

@@ -52,15 +52,17 @@ MCP config. Restart Claude Code and it has tools like
 `mcp__codebrain__ask_codebase`, plus a few dozen more. It uses them on
 its own.
 
-Manual config (any MCP-compatible client):
+Manual config — drop `.mcp.json` at **your project's root** (not in a
+global config). CodeBrain's index lives in `<repo>/.codebrain/`, so a
+global config would make every Claude session in every project fight
+over the same database. `brain setup` writes the right thing for you.
 
 ```json
 {
   "mcpServers": {
     "codebrain": {
       "command": "python",
-      "args": ["-m", "codebrain.mcp_server"],
-      "env": { "CODEBRAIN_PROJECT": "/absolute/path/to/repo" }
+      "args": ["-m", "codebrain.mcp_server"]
     }
   }
 }

{codebrain-0.3.1 → codebrain-0.3.3}/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.1"
+    __version__ = "0.3.3"

{codebrain-0.3.1 → codebrain-0.3.3}/codebrain/cli.py

@@ -398,32 +398,34 @@ def setup(ctx: click.Context, force: bool) -> None:
         claude_md.write_text(content)
         click.echo(f"Created {claude_md}")
 
-    # 3. Configure MCP globally
-    settings_path = Path.home() / ".claude" / "settings.json"
-    settings_path.parent.mkdir(parents=True, exist_ok=True)
-    if settings_path.exists():
-        settings = json.loads(settings_path.read_text())
+    # 3. Configure MCP scoped to *this* project via .mcp.json
+    #
+    # Project-local config is the right scope: CodeBrain's DB lives in
+    # <repo>/.codebrain/, the MCP only makes sense for the repo it was
+    # indexed against, and a global config makes every Claude session in
+    # every project fight over the same DB and PID file.
+    mcp_config_path = repo_root / ".mcp.json"
+    if mcp_config_path.exists():
+        try:
+            mcp_config = json.loads(mcp_config_path.read_text())
+        except json.JSONDecodeError:
+            mcp_config = {}
+    else:
+        mcp_config = {}
+    mcp_config.setdefault("mcpServers", {})
+    if "codebrain" in mcp_config["mcpServers"] and not force:
+        click.echo(f"MCP server already configured in {mcp_config_path}")
     else:
-        settings = {}
-    if "mcpServers" not in settings:
-        settings["mcpServers"] = {}
-    if "codebrain" not in settings["mcpServers"]:
-        # Find the codebrain package location
-        import codebrain
-        cb_root = str(Path(codebrain.__file__).parent.parent)
-        settings["mcpServers"]["codebrain"] = {
+        mcp_config["mcpServers"]["codebrain"] = {
             "command": "python",
             "args": ["-m", "codebrain.mcp_server"],
-            "cwd": cb_root,
         }
-        settings_path.write_text(json.dumps(settings, indent=2))
-        click.echo(f"Added CodeBrain MCP server to {settings_path}")
-    else:
-        click.echo("MCP server already configured")
+        mcp_config_path.write_text(json.dumps(mcp_config, indent=2) + "\n")
+        click.echo(f"Wrote MCP config to {mcp_config_path}")
 
     click.echo()
-    click.echo(click.style("Done! Restart Claude Code to activate.", bold=True))
-    click.echo("Claude Code will now use CodeBrain tools to understand your codebase.")
+    click.echo(click.style("Done! Restart Claude Code (in this repo) to activate.", bold=True))
+    click.echo("On first launch Claude Code will ask you to approve the project MCP server.")
 
 
 def _generate_claude_md(project_name: str) -> str:

{codebrain-0.3.1 → codebrain-0.3.3}/codebrain/mcp_lifecycle.py

@@ -34,6 +34,12 @@ PARENT_POLL_SECONDS = 5
 IDLE_TIMEOUT_SECONDS = int(os.environ.get("CODEBRAIN_MCP_IDLE_TIMEOUT", "1800"))
 MAX_LIFETIME_SECONDS = int(os.environ.get("CODEBRAIN_MCP_MAX_LIFETIME", "0"))
 STALE_AGE_SECONDS = 3600  # 1h with no parent-death signal still counts as stale
+ANCESTOR_WALK_DEPTH = 6
+# Names of host processes that own the MCP lifecycle. If any of these is found
+# while walking up the ancestor chain, we watch *it* rather than the immediate
+# parent — survives transient launchers (cmd.exe, Electron worker shells) that
+# Claude Code uses on Windows. Match is case-insensitive substring.
+HOST_PROCESS_NAME_HINTS = ("claude", "cursor", "vscode", "code")
 
 _last_activity_lock = threading.Lock()
 _last_activity: float = time.time()
@@ -73,6 +79,38 @@ def _read_pid_file(pid_file: Path) -> int | None:
         return None
 
 
+def _predecessor_has_live_host(pid: int) -> bool:
+    """True if ``pid``'s ancestor chain contains a live host (claude/cursor/...).
+
+    Such a predecessor belongs to a *concurrent* sibling Claude session and
+    must not be terminated — its disappearance would silently break that
+    session's MCP. Without psutil we cannot tell, so be safe and assume yes.
+    """
+    try:
+        import psutil
+    except ImportError:
+        return True
+    try:
+        proc = psutil.Process(pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return False
+    for _ in range(ANCESTOR_WALK_DEPTH):
+        try:
+            parent = proc.parent()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+        if parent is None:
+            return False
+        try:
+            name = (parent.name() or "").lower()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+        if any(hint in name for hint in HOST_PROCESS_NAME_HINTS):
+            return True
+        proc = parent
+    return False
+
+
 def _kill_stale_predecessor(pid_file: Path) -> None:
     if not pid_file.exists():
         return
@@ -90,6 +128,12 @@ def _kill_stale_predecessor(pid_file: Path) -> None:
         # PID was reused by an unrelated process. Don't touch.
         _log.debug("PID %d reused by unrelated process; leaving alone", old_pid)
         return
+    if _predecessor_has_live_host(old_pid):
+        # Concurrent sibling Claude session is still using this MCP — leave it.
+        # Without this, two Claude windows on the same repo race each other and
+        # whichever started last kills the other's MCP.
+        _log.debug("PID %d has a live IDE host; sibling MCP, leaving alone", old_pid)
+        return
     try:
         proc = psutil.Process(old_pid)
         _log.warning("Killing stale CodeBrain MCP predecessor PID %d", old_pid)
@@ -123,6 +167,54 @@ def _remove_pid_file(pid_file: Path) -> None:
         pass
 
 
+def _find_watch_target(start_pid: int) -> tuple[int, float | None]:
+    """Pick the PID whose death should kill the MCP.
+
+    Walks up the ancestor chain (up to ANCESTOR_WALK_DEPTH levels) looking
+    for a process whose name matches HOST_PROCESS_NAME_HINTS — that's the
+    real IDE host. Falls back to ``start_pid`` if no hint matches, psutil
+    is unavailable, or ``CODEBRAIN_MCP_DISABLE_ANCESTOR_WALK=1`` is set.
+
+    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
+    causes the parent watchdog to mis-fire while Claude Code is still up.
+    """
+    try:
+        import psutil
+    except ImportError:
+        return start_pid, None
+
+    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
+
+    if os.environ.get("CODEBRAIN_MCP_DISABLE_ANCESTOR_WALK") == "1":
+        return start_pid, fallback_create_time
+
+    try:
+        proc = psutil.Process(start_pid)
+        for _ in range(ANCESTOR_WALK_DEPTH):
+            try:
+                name = (proc.name() or "").lower()
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                break
+            if any(hint in name for hint in HOST_PROCESS_NAME_HINTS):
+                return proc.pid, proc.create_time()
+            try:
+                parent = proc.parent()
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                break
+            if parent is None:
+                break
+            proc = parent
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        pass
+    return start_pid, fallback_create_time
+
+
 def _parent_watchdog(initial_ppid: int, initial_create_time: float | None) -> None:
     try:
         import psutil
@@ -192,17 +284,13 @@ def install_watchdogs(repo_root: Path | None = None) -> None:
         _write_pid_file(pid_file)
         atexit.register(_remove_pid_file, pid_file)
 
-    initial_ppid = os.getppid()
-    initial_create_time: float | None = None
-    try:
-        import psutil
-        initial_create_time = psutil.Process(initial_ppid).create_time()
-    except Exception:
-        pass
+    immediate_ppid = os.getppid()
+    initial_ppid, initial_create_time = _find_watch_target(immediate_ppid)
 
     _log.info(
-        "MCP watchdogs installed (ppid=%d, idle_timeout=%ds, max_lifetime=%ds)",
+        "MCP watchdogs installed (ppid=%d via=%d, idle_timeout=%ds, max_lifetime=%ds)",
         initial_ppid,
+        immediate_ppid,
         IDLE_TIMEOUT_SECONDS,
         MAX_LIFETIME_SECONDS,
     )

{codebrain-0.3.1 → codebrain-0.3.3}/codebrain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebrain
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -123,15 +123,17 @@ MCP config. Restart Claude Code and it has tools like
 `mcp__codebrain__ask_codebase`, plus a few dozen more. It uses them on
 its own.
 
-Manual config (any MCP-compatible client):
+Manual config — drop `.mcp.json` at **your project's root** (not in a
+global config). CodeBrain's index lives in `<repo>/.codebrain/`, so a
+global config would make every Claude session in every project fight
+over the same database. `brain setup` writes the right thing for you.
 
 ```json
 {
   "mcpServers": {
     "codebrain": {
       "command": "python",
-      "args": ["-m", "codebrain.mcp_server"],
-      "env": { "CODEBRAIN_PROJECT": "/absolute/path/to/repo" }
+      "args": ["-m", "codebrain.mcp_server"]
     }
   }
 }

{codebrain-0.3.1 → codebrain-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codebrain"
-version = "0.3.1"
+version = "0.3.3"
 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.3.1 → codebrain-0.3.3}/tests/test_mcp_lifecycle.py

@@ -109,6 +109,73 @@ def test_find_db_lock_holder_skips_unrelated_process(tmp_path):
     assert ml.find_db_lock_holder(tmp_path) is None
 
 
+def test_find_watch_target_falls_back_when_no_host_match(monkeypatch):
+    """No claude/cursor/etc. ancestor → return the start pid unchanged."""
+    psutil = pytest.importorskip("psutil")
+
+    class _Proc:
+        def __init__(self, pid, name, parent=None, ctime=123.0):
+            self.pid = pid
+            self._name = name
+            self._parent = parent
+            self._ctime = ctime
+        def name(self): return self._name
+        def parent(self): return self._parent
+        def create_time(self): return self._ctime
+
+    great = _Proc(10, "init")
+    grand = _Proc(11, "bash", parent=great, ctime=200.0)
+    parent = _Proc(12, "python", parent=grand, ctime=300.0)
+
+    def fake_process(pid):
+        return {10: great, 11: grand, 12: parent}[pid]
+
+    monkeypatch.setattr(psutil, "Process", fake_process)
+    pid, ctime = ml._find_watch_target(12)
+    assert pid == 12
+    assert ctime == 300.0
+
+
+def test_find_watch_target_walks_to_claude(monkeypatch):
+    """Ancestor named claude.exe → watch that, not the immediate parent."""
+    psutil = pytest.importorskip("psutil")
+
+    class _Proc:
+        def __init__(self, pid, name, parent=None, ctime=0.0):
+            self.pid = pid
+            self._name = name
+            self._parent = parent
+            self._ctime = ctime
+        def name(self): return self._name
+        def parent(self): return self._parent
+        def create_time(self): return self._ctime
+
+    claude = _Proc(100, "claude.exe", ctime=1000.0)
+    launcher = _Proc(200, "cmd.exe", parent=claude, ctime=2000.0)
+    py = _Proc(300, "python.exe", parent=launcher, ctime=3000.0)
+
+    monkeypatch.setattr(psutil, "Process", lambda pid: {100: claude, 200: launcher, 300: py}[pid])
+    pid, ctime = ml._find_watch_target(300)
+    assert pid == 100
+    assert ctime == 1000.0
+
+
+def test_find_watch_target_handles_no_psutil(monkeypatch):
+    """psutil missing → return start_pid with no create_time."""
+    import builtins
+    real_import = builtins.__import__
+
+    def blocked(name, *a, **k):
+        if name == "psutil":
+            raise ImportError("simulated")
+        return real_import(name, *a, **k)
+
+    monkeypatch.setattr(builtins, "__import__", blocked)
+    pid, ctime = ml._find_watch_target(42)
+    assert pid == 42
+    assert ctime is None
+
+
 def test_install_watchdogs_is_idempotent(tmp_path, monkeypatch):
     monkeypatch.setattr(ml, "_installed", False)
     ml.install_watchdogs(tmp_path)
@@ -129,8 +196,11 @@ def test_install_watchdogs_kills_stale_predecessor(tmp_path, monkeypatch):
     """A previous PID file pointing to a real codebrain.mcp_server should be
     killed. We simulate by spawning a real subprocess that imports
     codebrain.mcp_server (so the cmdline check passes), then writing its
-    PID."""
+    PID. The host-detection is stubbed because the pytest runner's ancestor
+    chain may legitimately contain an IDE host on dev machines (VS Code,
+    PyCharm) which would otherwise correctly spare the spawned process."""
     monkeypatch.setattr(ml, "_installed", False)
+    monkeypatch.setattr(ml, "_predecessor_has_live_host", lambda _pid: False)
     pid_file = tmp_path / CODEBRAIN_DIR / "mcp.pid"
     pid_file.parent.mkdir(parents=True)
 
@@ -156,6 +226,68 @@ def test_install_watchdogs_kills_stale_predecessor(tmp_path, monkeypatch):
             proc.kill()
 
 
+def test_kill_stale_predecessor_spares_sibling_with_live_host(tmp_path, monkeypatch):
+    """Predecessor whose ancestor chain contains a live IDE host represents a
+    concurrent sibling Claude session — must not be terminated."""
+    pytest.importorskip("psutil")
+    monkeypatch.setattr(ml, "_predecessor_has_live_host", lambda _pid: True)
+
+    proc = subprocess.Popen(
+        [sys.executable, "-c", "import time; time.sleep(10)", "codebrain.mcp_server"],
+    )
+    try:
+        time.sleep(0.3)
+        pid_file = tmp_path / "mcp.pid"
+        pid_file.write_text(f"{proc.pid}\n0\n")
+
+        ml._kill_stale_predecessor(pid_file)
+
+        time.sleep(0.5)
+        assert proc.poll() is None, "Sibling MCP killed despite live host"
+    finally:
+        proc.kill()
+        proc.wait(timeout=5)
+
+
+def test_predecessor_has_live_host_returns_true_for_claude_ancestor(monkeypatch):
+    psutil = pytest.importorskip("psutil")
+
+    class _Proc:
+        def __init__(self, pid, name, parent=None):
+            self.pid = pid
+            self._name = name
+            self._parent = parent
+        def name(self): return self._name
+        def parent(self): return self._parent
+
+    claude = _Proc(100, "claude.exe")
+    cmd = _Proc(200, "cmd.exe", parent=claude)
+    py = _Proc(300, "python.exe", parent=cmd)
+    monkeypatch.setattr(psutil, "Process", lambda pid: {100: claude, 200: cmd, 300: py}[pid])
+
+    assert ml._predecessor_has_live_host(300) is True
+
+
+def test_predecessor_has_live_host_returns_false_for_orphan(monkeypatch):
+    psutil = pytest.importorskip("psutil")
+
+    class _Proc:
+        def __init__(self, pid, name, parent=None):
+            self.pid = pid
+            self._name = name
+            self._parent = parent
+        def name(self): return self._name
+        def parent(self): return self._parent
+
+    # python ← bash ← init — no IDE host anywhere.
+    init = _Proc(1, "init")
+    sh = _Proc(2, "bash", parent=init)
+    py = _Proc(3, "python.exe", parent=sh)
+    monkeypatch.setattr(psutil, "Process", lambda pid: {1: init, 2: sh, 3: py}[pid])
+
+    assert ml._predecessor_has_live_host(3) is False
+
+
 # ---------------------------------------------------------------------------
 # Stale-MCP discovery
 # ---------------------------------------------------------------------------
@@ -284,6 +416,10 @@ def test_parent_watchdog_exits_when_parent_dies(tmp_path):
 
     env = os.environ.copy()
     env["CB_TEST_REPO"] = str(tmp_path)
+    # Without this, _find_watch_target may walk past the test parent to the
+    # IDE running pytest (claude/cursor/code) and watch *that* — which stays
+    # alive when we kill the immediate parent, defeating the test.
+    env["CODEBRAIN_MCP_DISABLE_ANCESTOR_WALK"] = "1"
     parent = subprocess.Popen(
         [sys.executable, "-c", parent_script],
         stdout=subprocess.PIPE,