code-context-control 2.89.0__tar.gz → 2.89.1__tar.gz

{code_context_control-2.89.0/code_context_control.egg-info → code_context_control-2.89.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.89.0
+Version: 2.89.1
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.89.0 → code_context_control-2.89.1}/cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.89.0"
+__version__ = "2.89.1"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -4555,14 +4555,22 @@ def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None
             print(f"Warning: Could not update {antigravity_path} (global fallback skipped)")
 
 
-def _uninstall_mcp_all(project_path: str):
-    """Remove C3 MCP server configurations from all supported IDEs."""
+def _uninstall_mcp_all(project_path: str, include_global: bool = True):
+    """Remove C3 MCP server configurations from all supported IDEs.
+
+    ``include_global=False`` restricts removal to PROJECT-scoped config files
+    (the project's .mcp.json, .codex/config.toml, settings/hooks). Home-level
+    configs (~/.codex, Antigravity's mcp_config.json) are machine-wide and
+    shared by every C3 project, so per-project cleanup — the merge action's
+    ``cleanup='clear'`` — must never touch them; only a real machine
+    uninstall (the default) may."""
     import shutil
     from pathlib import Path
 
     from core.ide import PROFILES
 
-    print("\nRemoving C3 MCP server configurations...")
+    scope = "" if include_global else " (project-scoped only)"
+    print(f"\nRemoving C3 MCP server configurations...{scope}")
     target = Path(project_path).resolve()
 
     # Remove .mcp.json if it exists (standard MCP config file)
@@ -4587,11 +4595,12 @@ def _uninstall_mcp_all(project_path: str):
         # MCP Config paths to check
         config_paths = []
         if profile.config_path_global:
-            config_paths.append(Path.home() / profile.config_path)
+            if include_global:
+                config_paths.append(Path.home() / profile.config_path)
         else:
             config_paths.append(target / profile.config_path)
             # For Codex, also check the global fallback in home dir
-            if ide_name == "codex":
+            if ide_name == "codex" and include_global:
                 config_paths.append(Path.home() / profile.config_path)
 
         for mcp_config_path in config_paths:
@@ -4714,8 +4723,10 @@ def _uninstall_mcp_all(project_path: str):
                     print(f"  Warning: Could not update {vscode_settings_path}: {e}")
 
     # Legacy Gemini CLI configs (profile removed in v2.52) — still strip the c3 entry.
-    for legacy_cfg in (target / ".gemini" / "settings.json",
-                       Path.home() / ".gemini" / "settings.json"):
+    legacy_cfgs = [target / ".gemini" / "settings.json"]
+    if include_global:
+        legacy_cfgs.append(Path.home() / ".gemini" / "settings.json")
+    for legacy_cfg in legacy_cfgs:
         if not legacy_cfg.exists():
             continue
         try:

{code_context_control-2.89.0 → code_context_control-2.89.1/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.89.0
+Version: 2.89.1
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.89.0 → code_context_control-2.89.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.89.0"
+version = "2.89.1"
 description = "Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.89.0 → code_context_control-2.89.1}/services/parser.py

@@ -642,6 +642,7 @@ def check_syntax_ast(content: str, ext: str) -> List[Dict[str, Any]]:
 
 # ── Native syntax checking (no tree-sitter, no AI) ──────────────────
 import os as _os
+import shutil as _shutil
 import subprocess as _subprocess
 import sys as _sys
 import tempfile as _tempfile
@@ -715,6 +716,15 @@ def _result(status: str, checker: str, errors: List[Dict[str, Any]] | None = Non
 
 def _subproc_check(cmd: List[str], content: str, suffix: str, checker: str, timeout: int = 8) -> Dict[str, Any]:
     """Write content to a temp file and run a checker subprocess."""
+    # Resolve the checker through PATH before Popen: npm-global tools on
+    # Windows are .cmd batch shims (tsc.cmd, eslint.cmd) that CreateProcess
+    # will not find by bare name — shutil.which returns the full shim path,
+    # which Popen can execute. Bare-name Popen made every npm checker report
+    # "not installed" on Windows even when it was on PATH.
+    exe = _shutil.which(cmd[0])
+    if exe is None:
+        return _result("checker_unavailable", checker,
+                       detail=f"{cmd[0]} is not installed or not on PATH.")
     fd, tmp = _tempfile.mkstemp(suffix=suffix)
     try:
         with _os.fdopen(fd, 'w', encoding='utf-8') as f:
@@ -728,7 +738,7 @@ def _subproc_check(cmd: List[str], content: str, suffix: str, checker: str, time
         # the direct child, leaving any grandchild processes (e.g. Rscript -> R)
         # running. encoding/errors avoid UnicodeDecodeError on non-UTF-8 output.
         proc = _subprocess.Popen(
-            cmd + [tmp], stdin=_subprocess.DEVNULL,
+            [exe] + cmd[1:] + [tmp], stdin=_subprocess.DEVNULL,
             stdout=_subprocess.PIPE, stderr=_subprocess.PIPE,
             text=True, encoding="utf-8", errors="replace", **kwargs,
         )

{code_context_control-2.89.0 → code_context_control-2.89.1}/services/project_manager.py

@@ -819,7 +819,9 @@ class ProjectManager:
                 # Lazy import to avoid services -> cli circular import at module load.
                 from cli.c3 import _instruction_documents_for_project, _uninstall_mcp_all
                 try:
-                    _uninstall_mcp_all(str(src))
+                    # Project cleanup only — the machine-wide IDE registrations
+                    # (~/.codex, Antigravity) serve every other C3 project.
+                    _uninstall_mcp_all(str(src), include_global=False)
                 except Exception as e:
                     warnings.append(f"uninstall_mcp failed: {e}")
                 c3_dir = src / ".c3"

{code_context_control-2.89.0 → code_context_control-2.89.1}/tests/test_project_manager_merge.py

@@ -10,6 +10,7 @@ import sys
 import tempfile
 import unittest
 from pathlib import Path
+from unittest import mock
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 if str(REPO_ROOT) not in sys.path:
@@ -188,6 +189,73 @@ class TestMergeClear(_SandboxedRegistry):
         # Source directory itself still exists.
         self.assertTrue(src.is_dir())
 
+    def test_merge_clear_never_touches_machine_global_ide_configs(self):
+        # Regression: cleanup='clear' once ran the full machine uninstall,
+        # stripping C3 from the REAL ~/.codex/config.toml and deleting
+        # Antigravity's mcp_config.json — configs shared by every project.
+        fake_home = self.tmp_root / "home"
+        codex_cfg = fake_home / ".codex" / "config.toml"
+        codex_cfg.parent.mkdir(parents=True)
+        codex_body = '[mcp_servers.c3]\ncommand = "c3-mcp"\nenabled = true\n'
+        codex_cfg.write_text(codex_body, encoding="utf-8")
+        ag_cfg = fake_home / ".gemini" / "antigravity" / "mcp_config.json"
+        ag_cfg.parent.mkdir(parents=True)
+        ag_body = json.dumps({"mcpServers": {"c3": {"command": "c3-mcp"}}})
+        ag_cfg.write_text(ag_body, encoding="utf-8")
+
+        pm = ProjectManager()
+        src = _seed_project(self.tmp_root, "src3")
+        tgt = _seed_project(self.tmp_root, "tgt3")
+        pm.add_project(str(src))
+        pm.add_project(str(tgt))
+
+        with mock.patch("pathlib.Path.home", return_value=fake_home):
+            result = pm.merge_projects(str(src), str(tgt), cleanup="clear")
+        self.assertTrue(result.get("merged"), msg=result)
+        self.assertEqual(codex_cfg.read_text(encoding="utf-8"), codex_body,
+                         msg="~/.codex/config.toml must survive a project merge")
+        self.assertTrue(ag_cfg.exists(),
+                        msg="Antigravity mcp_config.json must survive a project merge")
+        self.assertEqual(ag_cfg.read_text(encoding="utf-8"), ag_body)
+
+
+class TestUninstallScope(_SandboxedRegistry):
+    """_uninstall_mcp_all: include_global gates every Path.home() touch."""
+
+    def _fixture(self):
+        fake_home = self.tmp_root / "home2"
+        codex_cfg = fake_home / ".codex" / "config.toml"
+        codex_cfg.parent.mkdir(parents=True)
+        codex_cfg.write_text('[mcp_servers.c3]\ncommand = "c3-mcp"\n',
+                             encoding="utf-8")
+        ag_cfg = fake_home / ".gemini" / "antigravity" / "mcp_config.json"
+        ag_cfg.parent.mkdir(parents=True)
+        ag_cfg.write_text(json.dumps({"mcpServers": {"c3": {"command": "x"}}}),
+                          encoding="utf-8")
+        proj = _seed_project(self.tmp_root, "scoped")
+        return fake_home, codex_cfg, ag_cfg, proj
+
+    def test_project_scope_leaves_home_configs_alone(self):
+        from cli.c3 import _uninstall_mcp_all
+        fake_home, codex_cfg, ag_cfg, proj = self._fixture()
+        with mock.patch("pathlib.Path.home", return_value=fake_home):
+            _uninstall_mcp_all(str(proj), include_global=False)
+        self.assertIn("[mcp_servers.c3]", codex_cfg.read_text(encoding="utf-8"))
+        self.assertTrue(ag_cfg.exists())
+
+    def test_global_scope_still_cleans_home_configs(self):
+        from cli.c3 import _uninstall_mcp_all
+        fake_home, codex_cfg, ag_cfg, proj = self._fixture()
+        with mock.patch("pathlib.Path.home", return_value=fake_home):
+            _uninstall_mcp_all(str(proj), include_global=True)
+        self.assertNotIn(
+            "[mcp_servers.c3]",
+            codex_cfg.read_text(encoding="utf-8") if codex_cfg.exists() else "",
+        )
+        if ag_cfg.exists():
+            cfg = json.loads(ag_cfg.read_text(encoding="utf-8"))
+            self.assertNotIn("c3", cfg.get("mcpServers", {}))
+
 
 class TestMergeValidation(_SandboxedRegistry):
     def test_rejects_identical_paths(self):

{code_context_control-2.89.0 → code_context_control-2.89.1}/tests/test_validate.py

@@ -98,6 +98,34 @@ class TestValidate(unittest.TestCase):
         self.assertEqual(result["checker"], "node --check")
         self.assertEqual(calls, ["node"])
 
+    def test_subproc_check_resolves_checker_through_which(self):
+        # npm-global tools on Windows are .cmd shims that a bare-name Popen
+        # cannot start — the checker must be launched by its resolved path.
+        seen = {}
+
+        class _FakeProc:
+            returncode = 0
+            def communicate(self, timeout=None):
+                return "", ""
+
+        def fake_popen(argv, **kw):
+            seen["argv0"] = argv[0]
+            return _FakeProc()
+
+        with patch("services.parser._shutil.which",
+                   return_value=r"C:\Users\u\AppData\Roaming\npm\tsc.CMD"), \
+             patch("services.parser._subprocess.Popen", side_effect=fake_popen):
+            result = parser._subproc_check(["tsc", "--noEmit"], "x", ".jsx", "tsc")
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(seen["argv0"], r"C:\Users\u\AppData\Roaming\npm\tsc.CMD")
+
+    def test_subproc_check_unresolved_checker_is_unavailable_without_popen(self):
+        with patch("services.parser._shutil.which", return_value=None), \
+             patch("services.parser._subprocess.Popen") as popen:
+            result = parser._subproc_check(["tsc", "--noEmit"], "x", ".jsx", "tsc")
+        self.assertEqual(result["status"], "checker_unavailable")
+        popen.assert_not_called()
+
     def test_timeout_wrapper_returns_timeout_status(self):
         import time