code-context-control 2.92.1__tar.gz → 2.92.3__tar.gz

{code_context_control-2.92.1/code_context_control.egg-info → code_context_control-2.92.3}/PKG-INFO

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

{code_context_control-2.92.1 → code_context_control-2.92.3/code_context_control.egg-info}/PKG-INFO

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

@@ -303,6 +303,7 @@ tests/test_circuit_breaker.py
 tests/test_claude_md_merge.py
 tests/test_cli_smoke.py
 tests/test_compressor_large_file.py
+tests/test_cooccurrence_bounds.py
 tests/test_cred_telemetry.py
 tests/test_credential_login_kind.py
 tests/test_credential_store.py

{code_context_control-2.92.1 → code_context_control-2.92.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.92.1"
+version = "2.92.3"
 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.92.1 → code_context_control-2.92.3}/services/bench/external/swe_bench.py

@@ -446,7 +446,9 @@ def evaluate_with_docker(
         "--timeout", str(timeout),
     ]
     try:
-        subprocess.run(cmd, check=True, timeout=timeout * len(list(predictions_path.read_text().splitlines())))
+        n_predictions = len(
+            predictions_path.read_text(encoding="utf-8").splitlines())
+        subprocess.run(cmd, check=True, timeout=timeout * n_predictions)
     except Exception as e:
         return {"error": str(e)}
 

{code_context_control-2.92.1 → code_context_control-2.92.3}/services/doc_index.py

@@ -113,7 +113,7 @@ class DocIndex:
                 except Exception:
                     pass
             try:
-                content = fpath.read_text(errors="replace")
+                content = fpath.read_text(encoding="utf-8", errors="replace")
             except Exception:
                 continue
 

{code_context_control-2.92.1 → code_context_control-2.92.3}/services/indexer.py

@@ -30,13 +30,27 @@ def _masked_content(fpath, project_path):
     if v.denial:
         return None
     if not v.masked:
-        return fpath.read_text(errors="replace")
+        return fpath.read_text(encoding="utf-8", errors="replace")
     try:
         return mask_mirror.render_for_path(fpath, project_path).text
     except Exception:
         return None
 
 
+# Co-occurrence is O(unique_tokens^2) per chunk, so one minified vendor
+# bundle can dominate a whole index build. Both bounds below are deliberate
+# and their effect is REPORTED in build_index()'s stats rather than applied
+# silently — a capped build must never look like a complete one.
+#
+# 200: chunks above this are minified/bundled/data blobs, not code. The
+# pruning step keeps only the top-5 co-occurring terms per token with at
+# least 3 hits, so such a chunk contributes noise that is discarded anyway.
+_COOC_MAX_CHUNK_TOKENS = 200
+# 20M: whole-pass ceiling on pair updates, so no repository shape can make
+# this step unbounded. ~10s of CPU on the boxes this runs on.
+_COOC_MAX_PAIR_UPDATES = 20_000_000
+
+
 class CodeIndex:
     """TF-IDF based code search index with structural awareness."""
 
@@ -187,7 +201,8 @@ class CodeIndex:
                         # (docs/mask-guard.md §6, row 2). Skip it instead.
                         continue
                 else:
-                    content = fpath.read_text(errors='replace')
+                    content = fpath.read_text(encoding='utf-8',
+                                              errors='replace')
             except Exception:
                 continue
 
@@ -239,6 +254,7 @@ class CodeIndex:
             "entries_scanned": scan_stats["entries"],
             "files_capped": files_capped,
             "max_files": max_files,
+            "cooccurrence": getattr(self, "_cooccurrence_stats", {}),
         }
 
     def _chunk_file(self, content: str, ext: str, doc_id: str) -> list:
@@ -624,16 +640,39 @@ class CodeIndex:
                 self.chunk_tfidf[chunk_id][term] = normalized_tf * self.idf.get(term, 0)
 
     def _build_cooccurrence(self):
-        """Build lightweight co-occurrence map from indexed chunks for auto-synonyms."""
+        """Build lightweight co-occurrence map from indexed chunks for auto-synonyms.
+
+        Bounded on purpose: the pair loop is quadratic in a chunk's unique
+        token count, so a single minified bundle (798 unique tokens x 4091
+        chunks = 1.9e9 pair updates, measured on a real project) can hang a
+        build that has nothing else wrong with it. Skipped chunks and an
+        exhausted budget are recorded in ``self._cooccurrence_stats`` and
+        returned by :meth:`build_index`.
+        """
         self._cooccurrence = {}
+        skipped = 0
+        updates = 0
+        budget_hit = False
         for chunk in self.chunks.values():
             tokens = set(self._tokenize(chunk["content"]))
+            if len(tokens) > _COOC_MAX_CHUNK_TOKENS:
+                skipped += 1
+                continue
+            if updates + len(tokens) * (len(tokens) - 1) > _COOC_MAX_PAIR_UPDATES:
+                budget_hit = True
+                break
             for t in tokens:
                 if t not in self._cooccurrence:
                     self._cooccurrence[t] = Counter()
                 for t2 in tokens:
                     if t != t2:
                         self._cooccurrence[t][t2] += 1
+            updates += len(tokens) * (len(tokens) - 1)
+        self._cooccurrence_stats = {
+            "chunks_skipped": skipped,
+            "pair_updates": updates,
+            "budget_exhausted": budget_hit,
+        }
         # Prune: keep only top-5 co-occurring terms per token (minimum 3 co-occurrences)
         pruned = {}
         for term, counts in self._cooccurrence.items():

{code_context_control-2.92.1 → code_context_control-2.92.3}/services/protocol.py

@@ -261,7 +261,7 @@ class CompressionProtocol:
                 if _sub_excluded(fpath):
                     continue
                 try:
-                    content = fpath.read_text(errors='replace')
+                    content = fpath.read_text(encoding='utf-8', errors='replace')
                 except Exception:
                     continue
                 _accumulate(content)

{code_context_control-2.92.1 → code_context_control-2.92.3}/services/scanner.py

@@ -43,7 +43,8 @@ def gitignore_dir_patterns(root) -> tuple:
     names: set = set()
     patterns: list = []
     try:
-        text = (Path(root) / '.gitignore').read_text(errors='replace')
+        text = (Path(root) / '.gitignore').read_text(encoding='utf-8',
+                                                     errors='replace')
     except OSError:
         return names, patterns
     for line in text.splitlines():

code_context_control-2.92.3/tests/test_cooccurrence_bounds.py

@@ -0,0 +1,96 @@
+"""The co-occurrence pass is quadratic per chunk and must stay bounded.
+
+Measured origin: a 139-file project whose vendor directory holds a minified
+CSS bundle produced 4091 chunks averaging 798 unique tokens. The unbounded
+pass needed ~1.9e9 Counter updates and pinned one core for over fifteen
+minutes on an index that is otherwise built in seconds.
+"""
+import tempfile
+import unittest
+from pathlib import Path
+
+from services import indexer as indexer_mod
+from services.indexer import CodeIndex
+
+
+def _word(i: int) -> str:
+    """Distinct lowercase word - the tokenizer keeps [a-zA-Z]{2,} only."""
+    a, b = divmod(i, 26)
+    c, a = divmod(a, 26)
+    return "zz" + chr(97 + c) + chr(97 + a) + chr(97 + b)
+
+
+def _minified_like(n_tokens: int) -> str:
+    """A single line of n distinct tokens - what a minified bundle looks like."""
+    return ".".join(_word(i) for i in range(n_tokens)) + "\n"
+
+
+class TestCooccurrenceBounds(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def _build(self):
+        idx = CodeIndex(str(self.root), str(self.root / ".c3" / "index"))
+        return idx, idx.build_index()
+
+    def test_token_dense_chunks_are_skipped_and_reported(self):
+        """A chunk past the cap contributes nothing - and says so."""
+        big = indexer_mod._COOC_MAX_CHUNK_TOKENS + 50
+        (self.root / "vendor.js").write_text(_minified_like(big), encoding="utf-8")
+        (self.root / "small.py").write_text(
+            "def alpha_helper():\n    return beta_helper\n", encoding="utf-8")
+
+        idx, result = self._build()
+        stats = result["cooccurrence"]
+
+        self.assertGreaterEqual(stats["chunks_skipped"], 1)
+        self.assertFalse(stats["budget_exhausted"])
+        # The skipped chunk's tokens are absent from the synonym map...
+        self.assertNotIn(_word(0), idx._cooccurrence)
+        # ...while the ordinary file was still processed.
+        self.assertLessEqual(
+            stats["pair_updates"],
+            indexer_mod._COOC_MAX_PAIR_UPDATES,
+        )
+
+    def test_pair_updates_never_exceed_the_budget(self):
+        """Many at-the-cap chunks stop the pass instead of running away."""
+        # Each file sits just under the per-chunk cap, so only the whole-pass
+        # budget can stop this.
+        per_chunk = indexer_mod._COOC_MAX_CHUNK_TOKENS
+        pairs_each = per_chunk * (per_chunk - 1)
+        n_files = (indexer_mod._COOC_MAX_PAIR_UPDATES // pairs_each) + 3
+        for i in range(n_files):
+            (self.root / f"f{i}.js").write_text(
+                _minified_like(per_chunk), encoding="utf-8")
+
+        _, result = self._build()
+        stats = result["cooccurrence"]
+
+        self.assertLessEqual(
+            stats["pair_updates"], indexer_mod._COOC_MAX_PAIR_UPDATES)
+        self.assertTrue(stats["budget_exhausted"])
+
+    def test_ordinary_project_is_unaffected(self):
+        """The bound must not change the synonym map for normal code."""
+        (self.root / "a.py").write_text(
+            "def alpha_helper():\n"
+            "    return beta_helper() + gamma_helper()\n", encoding="utf-8")
+        (self.root / "b.py").write_text(
+            "def beta_helper():\n"
+            "    return alpha_helper() + gamma_helper()\n", encoding="utf-8")
+
+        idx, result = self._build()
+        stats = result["cooccurrence"]
+
+        self.assertEqual(stats["chunks_skipped"], 0)
+        self.assertFalse(stats["budget_exhausted"])
+        self.assertGreater(stats["pair_updates"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

{code_context_control-2.92.1 → code_context_control-2.92.3}/tests/test_windows_reliability.py

@@ -2,6 +2,7 @@
 
 Locks in invariants that have bitten this project on Windows:
 - Text-mode open() calls must pass encoding='utf-8' so cp1252 doesn't corrupt JSON
+- Path.read_text()/write_text() must pass encoding='utf-8' for the same reason
 - No mojibake byte sequences in .py sources (re-encoding bugs decay silently)
 """
 from __future__ import annotations
@@ -12,7 +13,9 @@ from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 
-_SKIP_DIRS = {".venv", "__pycache__", ".pytest_cache", ".c3"}
+_SKIP_DIRS = {".venv", "__pycache__", ".pytest_cache", ".c3",
+              # Build artifacts: gitignored copies of sources we already scan.
+              "build", "dist", ".eggs"}
 _SKIP_FRAGMENTS = (".tmp.",)
 
 # Sequence produced when UTF-8 text is written then re-read as cp1252 and
@@ -63,6 +66,36 @@ def _find_open_calls_missing_encoding(text: str):
         yield line_no, call.replace("\n", " ")[:160]
 
 
+# Path.read_text/write_text default to locale encoding exactly like open().
+# `importlib.metadata` Distribution.read_text takes a FILENAME, not an encoding.
+_PATH_TEXT_CALL = re.compile(r"\.(read_text|write_text)\s*\(", re.MULTILINE)
+_PATH_TEXT_EXEMPT = re.compile(r"\b(dist|distribution)\.\s*$")
+
+
+def _find_path_text_calls_missing_encoding(text: str):
+    """Yield (line_no, call_text) for read_text/write_text without an encoding.
+
+    ``read_text('utf-8')`` (positional) counts: encoding is the first parameter.
+    """
+    for m in _PATH_TEXT_CALL.finditer(text):
+        if _PATH_TEXT_EXEMPT.search(text[max(0, m.start() - 24):m.start() + 1]):
+            continue
+        depth = 1
+        i = m.end()
+        while i < len(text) and depth > 0:
+            c = text[i]
+            if c == "(":
+                depth += 1
+            elif c == ")":
+                depth -= 1
+            i += 1
+        call = text[m.start():i]
+        if "encoding" in call or "utf-8" in call or "utf8" in call:
+            continue
+        line_no = text[: m.start()].count("\n") + 1
+        yield line_no, call.replace("\n", " ")[:160]
+
+
 class TestWindowsReliability(unittest.TestCase):
     def test_no_text_open_without_encoding(self):
         """Every text-mode open() in shipped code must pass encoding='utf-8'.
@@ -89,6 +122,37 @@ class TestWindowsReliability(unittest.TestCase):
                 + "\n  ".join(offenders)
             )
 
+    def test_no_path_text_io_without_encoding(self):
+        """Path.read_text()/write_text() must declare encoding='utf-8'.
+
+        The indexer, doc index, protocol dictionary and .gitignore scanner all
+        called ``read_text(errors='replace')`` with no encoding. On Windows
+        that decodes UTF-8 source as cp1252, and ``errors='replace'`` means it
+        never raises — every em dash landed in .c3/index, the doc index and the
+        chroma collection as the three-char mojibake this module's
+        ``_MOJIBAKE_EM_DASH`` matches. Source files were never touched; the
+        corruption lived only in the indexed copies served back to the agent.
+        """
+        offenders = []
+        for py in _iter_py_files():
+            # Shipped code only. Test fixtures write their own temp files and
+            # control both ends of the encoding.
+            if "tests" in py.relative_to(REPO_ROOT).parts:
+                continue
+            try:
+                text = py.read_text(encoding="utf-8")
+            except UnicodeDecodeError as e:
+                self.fail(f"{py} is not valid UTF-8: {e}")
+            for line_no, call in _find_path_text_calls_missing_encoding(text):
+                offenders.append(
+                    f"{py.relative_to(REPO_ROOT).as_posix()}:{line_no}: {call}")
+        if offenders:
+            self.fail(
+                "read_text()/write_text() calls missing encoding='utf-8' "
+                "(silently mojibake non-ASCII on Windows cp1252):\n  "
+                + "\n  ".join(offenders)
+            )
+
     def test_no_mojibake_bytes_in_sources(self):
         """No .py file should contain the UTF-8-re-encoded-as-cp1252 em-dash signature.