code-context-control 2.96.0__tar.gz → 2.96.1__tar.gz

{code_context_control-2.96.0/code_context_control.egg-info → code_context_control-2.96.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.96.0
+Version: 2.96.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.96.0 → code_context_control-2.96.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.96.0"
+__version__ = "2.96.1"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):

{code_context_control-2.96.0 → code_context_control-2.96.1/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.96.0
+Version: 2.96.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.96.0 → code_context_control-2.96.1}/code_context_control.egg-info/SOURCES.txt

@@ -421,6 +421,7 @@ tests/test_shell_creds.py
 tests/test_shell_robustness.py
 tests/test_shell_write_ledger.py
 tests/test_shell_writes.py
+tests/test_subproject_clear_scope.py
 tests/test_subproject_depth_consumers.py
 tests/test_subproject_exclusion.py
 tests/test_subproject_federation.py

{code_context_control-2.96.0 → code_context_control-2.96.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.96.0"
+version = "2.96.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.96.0 → code_context_control-2.96.1}/services/subprojects.py

@@ -629,7 +629,11 @@ class SubprojectManager:
                 # Same cleanup helpers merge_projects uses (lazy cli import).
                 from cli.c3 import _instruction_documents_for_project, _uninstall_mcp_all
                 try:
-                    _uninstall_mcp_all(str(abs_path))
+                    # Project cleanup only. ~/.codex and Antigravity's
+                    # mcp_config.json are machine-wide and serve every other
+                    # C3 project, so removing ONE sub-project must not
+                    # deregister C3 from the box.
+                    _uninstall_mcp_all(str(abs_path), include_global=False)
                 except Exception as e:
                     warnings.append(f"uninstall_mcp failed: {e}")
                 c3_dir = abs_path / ".c3"

code_context_control-2.96.1/tests/test_subproject_clear_scope.py

@@ -0,0 +1,118 @@
+"""``c3 sub remove --clear`` must not deregister C3 from the whole machine.
+
+2.89.1 fixed exactly this for the Hub's Merge action: ``cleanup='clear'``
+called ``_uninstall_mcp_all(src)`` — the MACHINE uninstall — which walks
+``Path.home()`` and strips C3 from ``~/.codex/config.toml`` and Antigravity's
+``mcp_config.json``. Those files are shared by every C3 project on the box, so
+cleaning up ONE project silently broke all of them. ``merge_projects`` was
+given ``include_global=False``; ``SubprojectManager.remove(mode='clear')``
+was not, and kept the bug until 2.96.1.
+
+Why no test caught it: ``SubprojectBase`` in ``test_subprojects.py`` patches
+``cli.c3._uninstall_mcp_all`` with a lambda that swallows every argument, so
+the one argument that mattered could not be observed. These tests deliberately
+run the REAL helper against a fake home, and assert on the files rather than on
+the call — a stub that ignores its kwargs cannot fail the way this bug did.
+"""
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from services import project_manager as pm_mod  # noqa: E402
+from services import subprojects as sp  # noqa: E402
+
+CODEX_BODY = '[mcp_servers.c3]\ncommand = "c3-mcp"\n'
+AG_BODY = json.dumps({"mcpServers": {"c3": {"command": "c3-mcp"}}})
+
+
+def _seed_c3_project(path: Path, name: str) -> Path:
+    (path / ".c3").mkdir(parents=True, exist_ok=True)
+    (path / ".c3" / "config.json").write_text(
+        json.dumps({"meta": {"name": name}}), encoding="utf-8")
+    return path
+
+
+class TestSubprojectClearScope(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.base = Path(self._tmp.name)
+
+        self.parent = _seed_c3_project(self.base / "parent", "parent")
+        # Deliberately OUTSIDE the parent: the external-link path is the one
+        # 2.96.0 made reachable, so it is the one that must be regression-proof.
+        self.child = _seed_c3_project(self.base / "elsewhere" / "child", "child")
+
+        self.reg_file = self.base / "projects.json"
+        self.reg_file.write_text(json.dumps({"projects": []}), encoding="utf-8")
+
+        self.home = self.base / "fakehome"
+        self.codex_cfg = self.home / ".codex" / "config.toml"
+        self.codex_cfg.parent.mkdir(parents=True)
+        self.codex_cfg.write_text(CODEX_BODY, encoding="utf-8")
+        self.ag_cfg = self.home / ".gemini" / "antigravity" / "mcp_config.json"
+        self.ag_cfg.parent.mkdir(parents=True)
+        self.ag_cfg.write_text(AG_BODY, encoding="utf-8")
+
+        self._patches = [
+            mock.patch.object(pm_mod, "_PROJECTS_FILE", self.reg_file),
+            mock.patch.object(pm_mod, "_REGISTRY_FILE", self.base / "registry.json"),
+            mock.patch("cli.c3._do_init", lambda *a, **k: None),
+        ]
+        for p in self._patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self._patches:
+            p.stop()
+        self._tmp.cleanup()
+
+    def _link_child(self):
+        mgr = sp.SubprojectManager(str(self.parent))
+        res = mgr.add(str(self.child), run_init=False, reindex_parent=False)
+        self.assertTrue(res.get("added"), msg=res)
+        return mgr
+
+    def test_clear_leaves_machine_wide_mcp_configs_alone(self):
+        mgr = self._link_child()
+        with mock.patch("pathlib.Path.home", return_value=self.home):
+            res = mgr.remove("child", mode="clear", reindex_parent=False)
+        self.assertTrue(res.get("removed"), msg=res)
+
+        self.assertEqual(
+            self.codex_cfg.read_text(encoding="utf-8"), CODEX_BODY,
+            msg="~/.codex/config.toml serves every C3 project on the box; "
+                "removing one sub-project must not touch it")
+        self.assertTrue(
+            self.ag_cfg.exists(),
+            msg="Antigravity mcp_config.json must survive a sub-project clear")
+        self.assertEqual(self.ag_cfg.read_text(encoding="utf-8"), AG_BODY)
+
+    def test_clear_still_removes_the_childs_own_files(self):
+        """The narrowed scope must not turn --clear into a no-op."""
+        mgr = self._link_child()
+        (self.child / "CLAUDE.md").write_text("x", encoding="utf-8")
+        with mock.patch("pathlib.Path.home", return_value=self.home):
+            res = mgr.remove("child", mode="clear", reindex_parent=False)
+        self.assertTrue(res.get("removed"), msg=res)
+        self.assertFalse((self.child / ".c3").exists(),
+                         msg="--clear must still wipe the child's own .c3")
+        self.assertFalse((self.child / "CLAUDE.md").exists(),
+                         msg="--clear must still remove the child's instruction docs")
+
+    def test_unlink_never_reaches_the_uninstall_helper_at_all(self):
+        mgr = self._link_child()
+        with mock.patch("cli.c3._uninstall_mcp_all") as spy:
+            res = mgr.remove("child", mode="unlink", reindex_parent=False)
+        self.assertTrue(res.get("removed"), msg=res)
+        spy.assert_not_called()
+        self.assertTrue((self.child / ".c3").exists(),
+                        msg="unlink keeps the child's .c3")
+
+
+if __name__ == "__main__":
+    unittest.main()

{code_context_control-2.96.0 → code_context_control-2.96.1}/tests/test_ui_jsx_syntax.py

@@ -14,6 +14,12 @@ be a plain `/* ... */`, or move above the conditional.
 The existing bundle tests check the SHAPE of the build (files listed, markers
 stamped, order kept) and passed the whole time the broken file was shipping.
 This one checks the property that actually broke.
+
+The transpile checks need node + `@babel/standalone`, and skip without them.
+That skip is correct on a dev box and dangerous in CI, because a summary line
+reading "2 passed, 2 skipped" is indistinguishable from a green run — so
+`C3_REQUIRE_JSX_TOOLCHAIN=1` turns a missing toolchain into a FAILURE. CI sets
+it; locally, `npm install --no-save @babel/standalone` makes the real parse run.
 """
 from __future__ import annotations
 
@@ -107,17 +113,56 @@ def _bundle_files(server_rel, const_name):
     return [REPO_ROOT / "cli" / rel for rel in _JS_STR.findall(match.group(1))]
 
 
+def _node_env():
+    """Environment for every node call, with the repo's own node_modules on it.
+
+    node resolves `require` relative to the SCRIPT's directory, and the parse
+    script below is written to a temp dir. A local `npm install` in the repo
+    root is therefore invisible to it, while a global install plus NODE_PATH
+    works — so the probe and the real run can disagree, the probe passing while
+    the run dies on MODULE_NOT_FOUND. Putting the repo's node_modules on
+    NODE_PATH makes both resolution paths agree and supports either install.
+    """
+    env = dict(os.environ)
+    local = REPO_ROOT / "node_modules"
+    existing = env.get("NODE_PATH", "")
+    if local.is_dir():
+        env["NODE_PATH"] = (str(local) + os.pathsep + existing) if existing else str(local)
+    return env
+
+
 def _toolchain_ready():
     try:
         probe = subprocess.run(
             ["node", "-e", "require.resolve('@babel/standalone'); console.log('y')"],
-            capture_output=True, text=True, timeout=60)
+            capture_output=True, text=True, timeout=60, env=_node_env())
     except (OSError, subprocess.SubprocessError):
         return False
     return probe.returncode == 0
 
 
-@unittest.skipUnless(_toolchain_ready(),
+# Skipping is right on a dev box with no node, and WRONG anywhere the
+# toolchain is supposed to be installed: "2 passed, 2 skipped" reads exactly
+# like a green run, so a broken `npm install` step would silently return CI to
+# the state that let 2.92.0-2.92.3 ship. Where the toolchain is promised, set
+# C3_REQUIRE_JSX_TOOLCHAIN=1 and a missing one FAILS instead of skipping.
+_TOOLCHAIN = _toolchain_ready()
+_REQUIRED = os.environ.get("C3_REQUIRE_JSX_TOOLCHAIN", "") not in ("", "0", "false")
+
+
+class TestToolchainAvailability(unittest.TestCase):
+    def test_toolchain_present_when_required(self):
+        if not _REQUIRED:
+            self.skipTest("C3_REQUIRE_JSX_TOOLCHAIN not set (local dev)")
+        self.assertTrue(
+            _TOOLCHAIN,
+            "C3_REQUIRE_JSX_TOOLCHAIN=1 but node + @babel/standalone did not "
+            "resolve, so the bundle transpile checks below would have SKIPPED "
+            "and the run would still have looked green. Install the toolchain "
+            "(`npm install --no-save @babel/standalone`) or unset the variable.")
+
+
+@unittest.skipUnless(_TOOLCHAIN,
                      "node + @babel/standalone unavailable (see module comment)")
 class TestBundlesActuallyTranspile(unittest.TestCase):
     def _check(self, server_rel, const_name):
@@ -129,7 +174,8 @@ class TestBundlesActuallyTranspile(unittest.TestCase):
             script = fh.name
         try:
             proc = subprocess.run(["node", script] + [str(f) for f in files],
-                                  capture_output=True, text=True, timeout=300)
+                                  capture_output=True, text=True, timeout=300,
+                                  env=_node_env())
         finally:
             os.unlink(script)
         self.assertEqual(