code-context-control 2.75.0__tar.gz → 2.76.2__tar.gz

{code_context_control-2.75.0/code_context_control.egg-info → code_context_control-2.76.2}/PKG-INFO

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

{code_context_control-2.75.0 → code_context_control-2.76.2}/cli/hook_access_guard.py

@@ -72,12 +72,59 @@ _IPV6_RE = re.compile(
 # so each became a hard deny on text that names no file at all.
 _SYNTAX_CHARS = frozenset("{}[]()<>\"'`|&*?")
 
+# `pkg/mod.py::TestThing`, `ns::Type` — a pytest node id or a C++/Rust scope.
+# NTFS spells a stream `file:name:$TYPE`, and the doubled-colon default-stream
+# form `file::$DATA` is real, so "contains ::" is NOT safe on its own. What is
+# safe is the type slot: stream types are `$`-prefixed system constants, so a
+# `::` NOT followed by `$` cannot be a stream spelling.
+_DOUBLE_COLON_RE = re.compile(r"::(?!\$)")
+
+# `<rev>:<path>` — how git names a blob: `git show HEAD:setup.py`,
+# `git cat-file -p origin/main:src/a.py`.
+_GIT_REVSPEC_RE = re.compile(r"^(?P<rev>[^:\s]+):(?P<path>[^:\s]+)$")
+_GIT_CMD_RE = re.compile(r"^\s*(?:[\w.\-]*[/\\])?git(?:\.exe)?\b", re.IGNORECASE)
+
 
 def _is_network_token(tok: str) -> bool:
     """True for URLs and IPv6 literals/CIDRs — never for an ADS spelling."""
     return bool(_SCHEME_RE.match(tok) or _IPV6_RE.match(tok))
 
 
+def _is_scope_token(tok: str) -> bool:
+    """True for `a/b.py::Thing` and `ns::Type` — never an ADS spelling."""
+    return bool(_DOUBLE_COLON_RE.search(tok))
+
+
+def _git_revspec_path(cmd: str, tok: str):
+    """The path half of a git ``<rev>:<path>`` token, or None.
+
+    Returned so the caller can check **the path** rather than the whole token,
+    which is the fix and a tightening at once. Today every git revspec is denied
+    by accident: ``<rev>:<path>`` canonicalizes to something with a residual
+    colon and trips ``<ads>``, so ``git show origin/main:pyproject.toml`` — an
+    everyday command naming nothing sensitive — is refused.
+
+    Whitelisting the shape outright would go too far the other way, because
+    ``git show HEAD:.env`` really does print a denied file's contents, and right
+    now the only thing stopping it is the false positive. Checking the path half
+    gets both right: `.env` is denied on its own rule, `pyproject.toml` is
+    allowed on its own merits, and neither answer depends on a rule misfiring.
+
+    Gated on the command actually being ``git``, since ``<word>:<word>`` means
+    something else almost everywhere else.
+    """
+    if not _GIT_CMD_RE.match(cmd or ""):
+        return None
+    if len(tok) > 1 and tok[1] == ":":
+        return None  # a drive letter is not a revspec separator
+    m = _GIT_REVSPEC_RE.match(tok)
+    if not m:
+        return None
+    path = m.group("path")
+    # A `$`-prefixed suffix is a stream type, not a path. Do not reinterpret it.
+    return None if path.startswith("$") else path
+
+
 def _looks_like_a_path(tok: str) -> bool:
     """False for tokens that are shell syntax rather than a path argument.
 
@@ -167,6 +214,16 @@ def _scan_shell(cmd: str, base: str):
         # a path at all" — and the second is the one that generalizes.
         if not _looks_like_a_path(tok) or _is_network_token(tok):
             continue
+        # `tests/x.py::TestThing` is a node id, not a stream spelling.
+        if _is_scope_token(tok):
+            continue
+        # `git show <rev>:<path>` — judge the PATH, not the whole token. This
+        # is the one place the scan rewrites what it checks rather than skipping
+        # it, because skipping would let `git show HEAD:.env` through.
+        revspec_path = _git_revspec_path(cmd, tok)
+        from_revspec = revspec_path is not None
+        if from_revspec:
+            tok = revspec_path
         if re.match(r"^/[a-z]/", tok):  # MSYS /c/foo → C:/foo
             tok = f"{tok[1]}:{tok[2:]}"
         denial = ag.check(tok, "read", base)
@@ -176,7 +233,11 @@ def _scan_shell(cmd: str, base: str):
                 exists = (p if p.is_absolute() else Path(base) / p).exists()
             except OSError:
                 exists = False
-            if exists or denial.rule.startswith("<"):
+            # A revspec names a path in HISTORY, so the working tree is the
+            # wrong place to ask whether it is real. `git show HEAD~5:.env`
+            # reads a denied file whether or not that file exists today, and
+            # existence-gating it would be a hole this rewrite opened.
+            if exists or from_revspec or denial.rule.startswith("<"):
                 return denial, tok
     return None, ""
 

{code_context_control-2.75.0 → code_context_control-2.76.2}/cli/tools/edit.py

@@ -387,10 +387,12 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
         tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
         n_new = new_string.count("\n") + 1 if new_string else 0
         create_summary = summary or f"Created {rel} ({n_new}L)"
-        _log_to_ledger(rel, create_summary, tag_list, svc,
-                       detail={"old_string": "", "new_string": new_string[:_DETAIL_CAP], "created": True})
+        deferred = _log_to_ledger(
+            rel, create_summary, tag_list, svc,
+            detail={"old_string": "", "new_string": new_string[:_DETAIL_CAP], "created": True})
         short = f"✓ {rel} [created, +{n_new}L]" + (f" — {summary}" if summary else "")
-        return finalize("c3_edit", {"file": file_path}, short, f"{rel} created")
+        return finalize("c3_edit", {"file": file_path}, short + deferred,
+                        f"{rel} created")
 
     # Parse tag list once
     tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
@@ -477,6 +479,7 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
                                 f"Write error: {e}", "write error")
 
         # Log batch to ledger as one entry (store each patch's old/new for diff view)
+        deferred = ""
         if any_applied:
             batch_detail = {"patches": [
                 {
@@ -486,7 +489,9 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
                 }
                 for p in edit_list if p.get("old_string") is not None
             ]}
-            _log_to_ledger(rel, summary or f"Batch edit: {len(edit_list)} patches", tag_list, svc, detail=batch_detail)
+            deferred = _log_to_ledger(
+                rel, summary or f"Batch edit: {len(edit_list)} patches",
+                tag_list, svc, detail=batch_detail)
 
         # Classify from the structured status list, not by substring-scanning
         # the human-readable result lines — a patch *summary* containing words
@@ -499,7 +504,7 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
             short += "\n" + "\n".join(failed)
             if first_miss:
                 short += first_miss
-        return finalize("c3_edit", {"file": file_path}, short,
+        return finalize("c3_edit", {"file": file_path}, short + deferred,
                         f"{rel} patched ({len(edit_list)} patches)")
 
     # ── Single-edit mode ──────────────────────────────────────────────────────
@@ -548,7 +553,8 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
     }
     if used_fallback:
         single_detail["unicode_normalized"] = True
-    _log_to_ledger(rel, auto_summary, tag_list, svc, detail=single_detail)
+    deferred = _log_to_ledger(rel, auto_summary, tag_list, svc,
+                              detail=single_detail)
 
     n_old = old_string.count("\n") + 1
     n_new = new_string.count("\n") + 1
@@ -556,14 +562,73 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
     occ = f" ({occurrences}x)" if occurrences > 1 else ""
     norm_tag = " [unicode-normalized]" if used_fallback else ""
     short = f"✓ {rel} [{delta}]{occ}{norm_tag}" + (f" — {summary}" if summary else "")
-    return finalize("c3_edit", {"file": file_path}, short, f"{rel} patched")
+    return finalize("c3_edit", {"file": file_path}, short + deferred,
+                    f"{rel} patched")
 
 
 _DETAIL_CAP = 2000  # chars stored per old/new string in the ledger
 
+#: How long the post-write bookkeeping gets before the caller stops waiting on
+#: it. Normal is milliseconds — a JSONL append and a git call that already caps
+#: itself at 4s. Ten seconds is far outside normal and far inside the harness's
+#: idle timeout, which is the number this exists to stay away from.
+_LEDGER_DEADLINE_S = 10.0
+
+_DEFERRED_NOTE = (
+    "\n  [c3:ledger-deferred] The FILE WRITE SUCCEEDED. Recording it in the "
+    "ledger outran {sec:.0f}s and was left running in the background, so the "
+    "edit may be missing from c3_edits history and from "
+    "c3_edits(action='verify') corroboration.\n"
+    "  Do not re-apply this edit on the strength of that absence — the file is "
+    "the evidence, and it already has the change."
+)
+
+
+def _log_to_ledger(rel: str, summary: str, tag_list, svc,
+                   detail: dict = None) -> str:
+    """Record an edit in the ledger, activity log, and session manager.
+
+    Never raises, and — since #74 — never blocks the caller indefinitely.
+
+    The write has already happened by the time this runs. That ordering is what
+    makes a stall here so expensive: one logged `c3_edit` hung until the harness
+    aborted it at 1800s while the file on disk was already correct, so half an
+    hour bought a report of work that had finished in milliseconds.
+
+    The host-side cause of that stall is not C3's (see #74 — the box hits
+    commit-charge exhaustion in short unpredictable windows), and nothing here
+    prevents it. What this does prevent is *paying 1800s to find out*. The
+    bookkeeping runs on a daemon thread; if it outlives the deadline the caller
+    returns anyway, with the response saying plainly that the write landed and
+    the record may not have. The thread is left alone rather than killed — it
+    may well finish a moment later, and a half-written ledger entry would be
+    worse than a late one.
+
+    Returns "" normally, or a note to append to the response when the deadline
+    passed. Reporting a degraded record is the point; a silent one would make
+    this indistinguishable from a clean run, which is the failure class this
+    whole subsystem exists to remove.
+    """
+    if not svc.edit_ledger:
+        return ""
+    done = threading.Event()
+
+    def _record() -> None:
+        try:
+            _log_to_ledger_blocking(rel, summary, tag_list, svc, detail)
+        finally:
+            done.set()
+
+    threading.Thread(target=_record, name="c3-edit-ledger",
+                     daemon=True).start()
+    if done.wait(_LEDGER_DEADLINE_S):
+        return ""
+    return _DEFERRED_NOTE.format(sec=_LEDGER_DEADLINE_S)
+
 
-def _log_to_ledger(rel: str, summary: str, tag_list, svc, detail: dict = None) -> None:
-    """Log an edit to the ledger, activity log, and session manager. Never raises."""
+def _log_to_ledger_blocking(rel: str, summary: str, tag_list, svc,
+                            detail: dict = None) -> None:
+    """The bookkeeping itself. Never raises; may block. Always run on a thread."""
     if not svc.edit_ledger:
         return
     try:

{code_context_control-2.75.0 → code_context_control-2.76.2/code_context_control.egg-info}/PKG-INFO

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

@@ -136,6 +136,7 @@ oracle/services/activity_reporter.py
 oracle/services/api_auth.py
 oracle/services/c3_bridge.py
 oracle/services/chat_engine.py
+oracle/services/chat_poll.py
 oracle/services/chat_store.py
 oracle/services/cross_memory.py
 oracle/services/discovery_audit.py
@@ -273,6 +274,7 @@ tests/test_bitbucket_credentials.py
 tests/test_bitbucket_tool.py
 tests/test_c3_bridge_project_artifacts.py
 tests/test_c3_shell.py
+tests/test_chat_poll.py
 tests/test_circuit_breaker.py
 tests/test_claude_md_merge.py
 tests/test_cli_smoke.py
@@ -284,6 +286,7 @@ tests/test_creds_cli_smoke.py
 tests/test_delegate_cascade.py
 tests/test_delegate_version_probe.py
 tests/test_e2e_benchmark.py
+tests/test_edit_ledger_deadline.py
 tests/test_edit_ledger_hook.py
 tests/test_edit_locking.py
 tests/test_edit_normalization.py
@@ -334,6 +337,7 @@ tests/test_memory_graph_api.py
 tests/test_memory_queue.py
 tests/test_memory_system.py
 tests/test_mobile_api.py
+tests/test_mobile_extras.py
 tests/test_mobile_override_routes.py
 tests/test_mobile_security_api.py
 tests/test_no_stale_model_pins.py

{code_context_control-2.75.0 → code_context_control-2.76.2}/oracle/oracle_server.py

@@ -248,11 +248,17 @@ def _local_write_guard():
 
 # ── Mobile gateway (companion app surface, /api/mobile/*) ─
 # Bearer required on every method, GETs included — see mobile_api docstring.
-from oracle.services import mobile_api  # noqa: E402
+from oracle.services import chat_poll, mobile_api  # noqa: E402
 
 mobile_api.configure(get_cfg=lambda: _cfg, get_limiter=_rate_limiter)
 app.register_blueprint(mobile_api.bp)
 
+# Poll-based chat transport (/api/mobile/chat/*) — phones cannot hold the SSE
+# connection /api/chat serves. Same bearer token, same engine generator.
+chat_poll.configure(get_engine=lambda: _chat_engine, get_store=lambda: _chat_store,
+                    get_cfg=lambda: _cfg)
+app.register_blueprint(chat_poll.bp)
+
 
 # ── Static ────────────────────────────────────────────────