code-context-control 2.110.0__tar.gz → 2.110.1__tar.gz

{code_context_control-2.110.0 → code_context_control-2.110.1}/PKG-INFO

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

{code_context_control-2.110.0 → code_context_control-2.110.1}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.110.0
+Version: 2.110.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.110.0 → code_context_control-2.110.1}/code_context_control.egg-info/SOURCES.txt

@@ -311,6 +311,7 @@ tests/test_ci_runner.py
 tests/test_ci_workflow.py
 tests/test_circuit_breaker.py
 tests/test_claude_md_merge.py
+tests/test_claude_md_updater.py
 tests/test_cli_smoke.py
 tests/test_compressor_large_file.py
 tests/test_confirm_guard.py

{code_context_control-2.110.0 → code_context_control-2.110.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.110.0"
+version = "2.110.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.110.0 → code_context_control-2.110.1}/services/agents.py

@@ -650,11 +650,12 @@ class ClaudeMdUpdaterAgent(BackgroundAgent):
 
         for action_type, data in actions:
             if action_type == "staleness":
-                # Regenerate the auto-generated sections
+                # Regenerate the auto-generated sections — inside the managed
+                # block, so user content around it survives.
                 try:
                     result = self.claude_md.generate(include_sessions=True)
                     if result.get("content") and self.auto_apply:
-                        self._write_claude_md(result["content"])
+                        self._write_managed_body(result["content"])
                         applied.append("Regenerated CLAUDE.md (stale)")
                     elif result.get("content"):
                         applied.append(f"CLAUDE.md is stale ({len(data.get('issues', []))} issues) — regeneration available")
@@ -810,16 +811,59 @@ class ClaudeMdUpdaterAgent(BackgroundAgent):
             self._write_claude_md("\n".join(lines))
         return additions
 
-    def _write_claude_md(self, content: str):
-        """Write content to the instructions file and update hash."""
+    def _md_path(self):
+        return self.claude_md.project_path / self.claude_md.instructions_file
+
+    def _write_managed_body(self, body: str) -> bool:
+        """Write regenerated C3 content INTO the managed block.
+
+        ``generate()`` returns the block body, not a whole file. Writing it
+        raw (2.110.0 and earlier) dropped the ``C3:BEGIN``/``C3:END`` markers
+        and everything the user kept outside them; the next ``c3 install-mcp``
+        then re-wrapped the template as a legacy doc, so a committed
+        CLAUDE.md went dirty on every session start. The merge in
+        ``write_c3_instruction_doc`` is the same one the installer uses.
+        """
+        from services.claude_md import write_c3_instruction_doc
+
         try:
-            md_path = self.claude_md.project_path / self.claude_md.instructions_file
+            final = write_c3_instruction_doc(self._md_path(), body,
+                                             project_path=self.claude_md.project_path,
+                                             source="claude_md_updater")
+            self._last_content_hash = hashlib.md5(final.encode()).hexdigest()
+            self._last_update_time = time.time()
+            return True
+        except Exception:
+            return False
+
+    def _write_claude_md(self, content: str) -> bool:
+        """Write a WHOLE instructions file (compaction, promotions) and update hash.
+
+        Refuses when the file on disk carries the managed-block markers and
+        ``content`` does not: that is a block body, and writing it here would
+        strip the markers — route it through ``_write_managed_body``.
+        """
+        from services.claude_md import C3_BLOCK_BEGIN
+
+        try:
+            md_path = self._md_path()
             md_path.parent.mkdir(parents=True, exist_ok=True)
+            if md_path.exists() and C3_BLOCK_BEGIN not in content:
+                existing = md_path.read_text(encoding="utf-8", errors="replace")
+                if C3_BLOCK_BEGIN in existing:
+                    return False
             md_path.write_text(content, encoding="utf-8")
             self._last_content_hash = hashlib.md5(content.encode()).hexdigest()
             self._last_update_time = time.time()
+        except Exception:
+            return False
+        try:
+            from services.artifact_defs import note_pending_write
+            note_pending_write(self.claude_md.project_path, self.claude_md.instructions_file,
+                               "claude_md_updater")
         except Exception:
             pass
+        return True
 
     def get_status(self) -> dict:
         """Extended status including updater-specific metrics."""

{code_context_control-2.110.0 → code_context_control-2.110.1}/services/claude_md.py

@@ -300,17 +300,19 @@ def strip_c3_block(existing: str) -> Optional[str]:
     return None
 
 
-def write_c3_instruction_doc(path, content: str, project_path=None) -> str:
+def write_c3_instruction_doc(path, content: str, project_path=None,
+                             source: str = "install_mcp") -> str:
     """Write a C3-generated instruction doc without clobbering user content.
 
     Wraps ``content`` in the C3 managed block and merges it into any existing
     file via :func:`merge_c3_block`. Returns the exact text written to disk.
 
-    Self-reports the write to the agent-artifact tracker (source=install_mcp)
-    so regeneration is attributed to C3 instead of surfacing as anonymous
-    out-of-band drift. ``project_path`` pins the project root; when omitted
-    it is inferred from the doc's location (root or one level down, e.g.
-    .github/copilot-instructions.md).
+    Self-reports the write to the agent-artifact tracker under ``source``
+    (``install_mcp`` for the installer and CLI, ``claude_md_updater`` for the
+    background agent) so regeneration is attributed to C3 instead of
+    surfacing as anonymous out-of-band drift. ``project_path`` pins the
+    project root; when omitted it is inferred from the doc's location (root
+    or one level down, e.g. .github/copilot-instructions.md).
     """
     p = Path(path)
     p.parent.mkdir(parents=True, exist_ok=True)
@@ -329,7 +331,7 @@ def write_c3_instruction_doc(path, content: str, project_path=None) -> str:
                          if (c / ".c3").is_dir()), None)
         if root is not None and (root / ".c3").is_dir():
             note_pending_write(root, str(p.resolve().relative_to(root.resolve())),
-                               "install_mcp")
+                               source or "install_mcp")
     except Exception:
         pass
     return final
@@ -533,13 +535,15 @@ class ClaudeMdManager:
                 ),
             })
 
-        # Structure drift
-        structure_issues = self._diff_structure(current)
-        issues.extend(structure_issues)
-
-        # Tech stack drift
-        tech_issues = self._diff_tech_stack(current)
-        issues.extend(tech_issues)
+        # Structure and tech-stack drift apply only to the legacy embedded
+        # tree. With the live repo map (default since 2.60.0) the doc carries
+        # neither — the map does — so there is nothing embedded to drift.
+        # Diffing anyway reported every detected technology as "not listed"
+        # on every check, and an auto-applying updater rewrote the file each
+        # time (2.110.1).
+        if not self._repo_map_enabled():
+            issues.extend(self._diff_structure(current))
+            issues.extend(self._diff_tech_stack(current))
 
         # Session staleness
         session_files = sorted(

code_context_control-2.110.1/tests/test_claude_md_updater.py

@@ -0,0 +1,163 @@
+"""The CLAUDE.md updater agent must not churn a managed instruction doc.
+
+Observed 2026-09-04 on the C3 repo itself: c3_artifacts history alternated
+``install_mcp`` / ``scan`` on every session start. Two defects composed:
+
+1. ``check_staleness`` diffed the project tree and tech stack against a doc
+   that, in repo-map mode (default since 2.60.0), carries neither — so every
+   detected technology was "not listed" and the doc was always stale.
+2. The updater wrote ``generate()``'s block body with a raw ``write_text``,
+   stripping the ``C3:BEGIN``/``C3:END`` markers and any user content around
+   them; the next ``c3 install-mcp`` re-wrapped the template as a legacy doc.
+
+These tests pin: no staleness in map mode; staleness still detected in
+legacy mode; regeneration lands inside the block with user notes intact; an
+installer-written doc survives an agent cycle byte for byte; whole-file
+writes refuse to drop markers; every agent write is attributed.
+"""
+
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from services import claude_md as cm
+from services.agents import ClaudeMdUpdaterAgent
+from services.claude_md import (
+    C3_BLOCK_BEGIN,
+    C3_BLOCK_END,
+    ClaudeMdManager,
+    wrap_c3_block,
+    write_c3_instruction_doc,
+)
+
+USER_HEAD = "# My notes\nkeep me above\n"
+USER_TAIL = "# User Notes\nkeep me below\n"
+
+
+def _session_mgr():
+    """Just enough SessionManager for the legacy (embedded tree) paths."""
+    return types.SimpleNamespace(
+        _detect_tech_stack=lambda: "python, javascript",
+        _scan_project_structure=lambda: "```\nsrc/\ndocs/\n```",
+        current_session=None,
+    )
+
+
+class _Project(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        (self.root / ".c3").mkdir()
+        (self.root / "src").mkdir()
+        (self.root / "docs").mkdir()
+        (self.root / "pyproject.toml").write_text("[project]\nname='x'\n", encoding="utf-8")
+        (self.root / "src" / "app.py").write_text("x = 1\n", encoding="utf-8")
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def config(self, cfg: dict):
+        (self.root / ".c3" / "config.json").write_text(json.dumps(cfg), encoding="utf-8")
+
+    def manager(self):
+        return ClaudeMdManager(str(self.root), _session_mgr(), None,
+                               types.SimpleNamespace(facts=[]))
+
+    def agent(self, mgr):
+        return ClaudeMdUpdaterAgent(
+            claude_md=mgr, memory=mgr.memory, session_mgr=mgr.session_mgr,
+            watcher=types.SimpleNamespace(_handler=types.SimpleNamespace(change_count=3)),
+            notifications=mock.MagicMock(), enabled=True, auto_apply=True)
+
+    def doc(self):
+        return self.root / "CLAUDE.md"
+
+    def write_managed(self, body: str) -> str:
+        """A managed doc with user notes above and below the block."""
+        text = USER_HEAD + "\n" + wrap_c3_block(body) + "\n\n" + USER_TAIL
+        self.doc().write_text(text, encoding="utf-8")
+        return text
+
+
+class TestStaleness(_Project):
+    def test_map_mode_is_not_stale_without_tree_or_tech_stack(self):
+        mgr = self.manager()
+        self.write_managed(mgr.generate()["content"])
+        result = mgr.check_staleness()
+        self.assertEqual(result["status"], "ok", result)
+        self.assertFalse([i for i in result["issues"] if "Tech Stack" in i["message"]])
+
+    def test_legacy_mode_still_reports_drift(self):
+        self.config({"map": {"enabled": False}})
+        mgr = self.manager()
+        # A doc that lists no tech stack and no tree: both diffs must fire.
+        self.write_managed("## C3 Tools — MANDATORY\nUse c3_* tools.\n")
+        result = mgr.check_staleness()
+        self.assertEqual(result["status"], "stale")
+        self.assertTrue(any("Tech Stack" in i["message"] for i in result["issues"]))
+
+
+class TestUpdaterWrites(_Project):
+    def test_installer_doc_survives_an_agent_cycle_in_map_mode(self):
+        mgr = self.manager()
+        before = self.write_managed(mgr.generate()["content"])
+        self.agent(mgr).check()
+        self.assertEqual(self.doc().read_text(encoding="utf-8"), before)
+
+    def test_regeneration_lands_inside_the_block(self):
+        self.config({"map": {"enabled": False}})
+        mgr = self.manager()
+        self.write_managed("## C3 Tools — MANDATORY\nstale body\n")
+        self.agent(mgr).check()
+        text = self.doc().read_text(encoding="utf-8")
+        self.assertEqual(text.count(C3_BLOCK_BEGIN), 1)
+        self.assertEqual(text.count(C3_BLOCK_END), 1)
+        self.assertTrue(text.startswith(USER_HEAD.rstrip()), text[:80])
+        self.assertTrue(text.rstrip().endswith(USER_TAIL.rstrip()), text[-80:])
+        self.assertIn("# Project Context", text)
+        self.assertNotIn("stale body", text)
+        self.assertLess(text.index(C3_BLOCK_BEGIN), text.index("# Project Context"))
+        self.assertLess(text.index("# Project Context"), text.index(C3_BLOCK_END))
+
+    def test_second_cycle_is_a_no_op(self):
+        self.config({"map": {"enabled": False}})
+        mgr = self.manager()
+        self.write_managed("## C3 Tools — MANDATORY\nstale body\n")
+        agent = self.agent(mgr)
+        agent.check()
+        once = self.doc().read_text(encoding="utf-8")
+        agent._last_action_hash = ""  # forget the dedupe; the doc must stand on its own
+        agent.check()
+        self.assertEqual(self.doc().read_text(encoding="utf-8"), once)
+
+    def test_whole_file_write_refuses_to_drop_markers(self):
+        mgr = self.manager()
+        before = self.write_managed("body")
+        agent = self.agent(mgr)
+        self.assertFalse(agent._write_claude_md("a block body with no markers"))
+        self.assertEqual(self.doc().read_text(encoding="utf-8"), before)
+        self.assertTrue(agent._write_claude_md(before.replace("body", "body2")))
+        self.assertIn("body2", self.doc().read_text(encoding="utf-8"))
+
+    def test_writes_are_attributed_to_the_agent(self):
+        mgr = self.manager()
+        before = self.write_managed("body")
+        agent = self.agent(mgr)
+        with mock.patch("services.artifact_defs.note_pending_write") as note:
+            agent._write_managed_body("new body")
+            agent._write_claude_md(before)
+        sources = [call.args[2] for call in note.call_args_list]
+        self.assertEqual(sources, ["claude_md_updater", "claude_md_updater"])
+
+    def test_installer_source_is_the_default(self):
+        with mock.patch("services.artifact_defs.note_pending_write") as note:
+            write_c3_instruction_doc(self.doc(), "body", project_path=self.root)
+        self.assertEqual(note.call_args.args[2], "install_mcp")
+        self.assertIs(cm.write_c3_instruction_doc, write_c3_instruction_doc)
+
+
+if __name__ == "__main__":
+    unittest.main()