code-context-control 2.92.2__tar.gz → 2.92.4__tar.gz

{code_context_control-2.92.2/code_context_control.egg-info → code_context_control-2.92.4}/PKG-INFO

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

{code_context_control-2.92.2 → code_context_control-2.92.4}/cli/hub_ui/components/topbar.js

@@ -67,10 +67,10 @@ function TopBar({ version, activeCount, darkMode, hubConfig, mainView, setMainVi
         <a href="https://github.com/sponsors/drknowhow" target="_blank" rel="noopener" title="Sponsor C3 development" style={ctrl}>
           <I name="heart" size={13} color="#EA4AAA" />
         </a>
+        {/* Goes through the hub, not straight at oracle_url: the hub redeems
+            the Oracle's owner-only bootstrap key so the tab lands signed in.
+            A raw link opens a read-only dashboard where every write 401s. */}
         {hubConfig && hubConfig.oracle_url && (
-          {/* Goes through the hub, not straight at oracle_url: the hub redeems
-              the Oracle's owner-only bootstrap key so the tab lands signed in.
-              A raw link opens a read-only dashboard where every write 401s. */}
           <a href="/api/oracle/open" target="_blank" rel="noopener" title="Open Oracle (signed in)" style={ctrl}>
             <I name="external" size={13} color={T.textMuted} />
           </a>

{code_context_control-2.92.2 → code_context_control-2.92.4/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.92.2
+Version: 2.92.4
 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.2 → code_context_control-2.92.4}/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
@@ -424,6 +425,7 @@ tests/test_task_tool.py
 tests/test_time_tracker.py
 tests/test_token_telemetry.py
 tests/test_tool_registry.py
+tests/test_ui_jsx_syntax.py
 tests/test_upgrade_and_version.py
 tests/test_validate.py
 tests/test_vault_write_guard.py

{code_context_control-2.92.2 → code_context_control-2.92.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.92.2"
+version = "2.92.4"
 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.2 → code_context_control-2.92.4}/services/indexer.py

@@ -37,6 +37,20 @@ def _masked_content(fpath, project_path):
         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."""
 
@@ -240,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:
@@ -625,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.4/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.4/tests/test_ui_jsx_syntax.py

@@ -0,0 +1,68 @@
+"""Guards the UI bundles against a JSX syntax error that only Babel sees.
+
+The hub, project and Oracle UIs are transpiled in the browser by
+`babel.min.js`. A syntax error anywhere in the concatenated script kills the
+whole bundle — the page renders black and the only clue is a console message,
+so nothing on the Python side notices. 2.92.0 through 2.92.3 shipped exactly
+that: a `{/* ... */}` comment placed directly inside `cond && ( ... )`.
+
+That position is expression context, not JSX children context, so Babel reads
+the `{` as an object literal and fails with `Unexpected token, expected ","`.
+A JSX comment is only legal between JSX tags; in expression position it has to
+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.
+"""
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+# Roots holding browser-transpiled JSX (shared project UI, hub UI, Oracle UI).
+UI_ROOTS = ("cli/ui", "cli/hub_ui", "oracle/ui")
+
+# A line that opens an expression paren: the next token must be an expression,
+# and `{/*` there is an object literal, not a comment.
+_OPENS_EXPRESSION = re.compile(r"(?:&&|\|\||\?|:|=>|=|\breturn\b|\(|,)\s*\($")
+
+
+def _ui_files() -> list[Path]:
+    files: list[Path] = []
+    for rel in UI_ROOTS:
+        root = REPO_ROOT / rel
+        if root.is_dir():
+            files.extend(sorted(root.rglob("*.js")))
+    return files
+
+
+class TestJsxCommentPlacement(unittest.TestCase):
+    def test_ui_roots_are_not_empty(self):
+        # A silent rename would make the scan below pass by finding nothing.
+        self.assertGreater(len(_ui_files()), 40, "UI file scan found almost nothing")
+
+    def test_no_jsx_comment_in_expression_position(self):
+        offenders = []
+        for path in _ui_files():
+            lines = path.read_text(encoding="utf-8").splitlines()
+            for i, line in enumerate(lines[:-1]):
+                if not _OPENS_EXPRESSION.search(line.rstrip()):
+                    continue
+                if lines[i + 1].lstrip().startswith("{/*"):
+                    rel = path.relative_to(REPO_ROOT).as_posix()
+                    offenders.append(f"{rel}:{i + 2}: {lines[i + 1].strip()[:60]}")
+        self.assertEqual(
+            offenders,
+            [],
+            "JSX comment in expression position — Babel reads `{` as an object "
+            "literal and the whole bundle fails to parse:\n  "
+            + "\n  ".join(offenders),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()