code-context-control 2.49.2__tar.gz → 2.50.0__tar.gz

{code_context_control-2.49.2/code_context_control.egg-info → code_context_control-2.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.49.2
+Version: 2.50.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.49.2 → code_context_control-2.50.0}/cli/tools/edit.py

@@ -8,6 +8,7 @@ Parallel safety:
 - Same file: serialized via per-file threading.Lock (_file_locks).
 - Same file, multiple hunks: use the `edits` batch parameter — one read/write cycle.
 """
+import difflib
 import json
 import threading
 from pathlib import Path
@@ -33,12 +34,16 @@ def _read_preserving_newlines(path: Path) -> tuple[str, str]:
     `newline` is the EOL to write back: ``\r\n`` if CRLF dominates the
     file, otherwise ``\n``. This avoids Python's text-mode write rewriting
     every line to ``os.linesep`` on Windows.
+
+    Decodes with errors="surrogateescape" so files containing non-UTF-8
+    bytes are still editable: invalid bytes round-trip losslessly through
+    _write_preserving_newlines instead of raising UnicodeDecodeError.
     """
     raw = path.read_bytes()
     crlf = raw.count(b"\r\n")
     lf_only = raw.count(b"\n") - crlf
     newline = "\r\n" if crlf > lf_only else "\n"
-    content = raw.decode("utf-8")
+    content = raw.decode("utf-8", errors="surrogateescape")
     # Normalize to \n internally so replacement matching is EOL-agnostic.
     content = content.replace("\r\n", "\n").replace("\r", "\n")
     return content, newline
@@ -52,7 +57,8 @@ def _write_preserving_newlines(path: Path, content: str, newline: str) -> None:
     """
     if newline != "\n":
         content = content.replace("\n", newline)
-    with open(path, "w", encoding="utf-8", newline="") as fh:
+    with open(path, "w", encoding="utf-8", errors="surrogateescape",
+              newline="") as fh:
         fh.write(content)
 
 
@@ -66,9 +72,23 @@ _LOOKALIKE_TRANS = str.maketrans({
     "′": "'", "″": '"',                                 # prime / double prime
     "‐": "-", "‑": "-", "‒": "-", "–": "-",  # hyphen / dashes
     "—": "-", "―": "-", "−": "-",
-    " ": " ", " ": " ", " ": " ",                  # non-breaking / figure / narrow-nbsp
+    "\u00a0": " ", "\u2007": " ", "\u202f": " ",  # non-breaking / figure / narrow-nbsp
 })
 
+# Bytes that aren't valid UTF-8 decode to lone surrogates U+DC80-U+DCFF under
+# errors="surrogateescape" (how _read_preserving_newlines reads files), while
+# c3_read renders those same bytes as U+FFFD (errors="replace"). Fold both to
+# U+FFFD — 1:1 like the lookalikes — so an old_string copied from c3_read
+# output still matches file content around undecodable bytes.
+_SURROGATE_TRANS = {c: "\ufffd" for c in range(0xDC80, 0xDD00)}
+_LOOKALIKE_TRANS.update(_SURROGATE_TRANS)
+
+
+def _display_safe(s: str) -> str:
+    """Fold surrogateescape'd bytes to U+FFFD for error-message display —
+    lone surrogates cannot be encoded for MCP transport."""
+    return s.translate(_SURROGATE_TRANS) if s else s
+
 
 def _norm(s: str) -> str:
     return s.translate(_LOOKALIKE_TRANS) if s else s
@@ -125,6 +145,81 @@ def _apply_replacement(content: str, old: str, new: str, replace_all: bool):
     return (_positional_replace(content, nc, no, new, replace_all), count, True)
 
 
+def _closest_region(content: str, old: str,
+                    max_scan_lines: int = 40000, context: int = 2):
+    """Locate the file region most similar to a failed old_string.
+
+    Returns (start_line, end_line, region_text, ratio) — 1-based inclusive
+    line numbers, region padded with `context` lines each side — or None when
+    no region clears the similarity floor. Powers the 'closest match' payload
+    in not-found errors so a mismatched edit can be repaired without
+    re-reading the file (the moment agents historically drifted back to
+    native Read).
+    """
+    file_lines = content.split("\n")
+    old_lines = old.split("\n")
+    n, total = len(old_lines), len(file_lines)
+    if not old.strip() or total > max_scan_lines:
+        return None
+
+    # Anchor on old_string's most distinctive line, shortlist file lines that
+    # resemble it (cheap quick_ratio pass), then score full windows aligned
+    # to each shortlisted line (expensive ratio, capped at 8 candidates).
+    anchor_off, anchor_line = max(enumerate(old_lines),
+                                  key=lambda p: len(p[1].strip()))
+    anchor = anchor_line.strip()
+    sm = difflib.SequenceMatcher(autojunk=False)
+    sm.set_seq2(anchor)
+    scored = []
+    for i, line in enumerate(file_lines):
+        sm.set_seq1(line.strip())
+        if sm.real_quick_ratio() < 0.6:
+            continue
+        q = sm.quick_ratio()
+        if q >= 0.6:
+            scored.append((q, i))
+    if not scored:
+        return None
+    scored.sort(key=lambda t: -t[0])
+
+    win = difflib.SequenceMatcher(autojunk=False)
+    win.set_seq2(old)
+    best_ratio, best_start = 0.0, None
+    for _, i in scored[:8]:
+        start = max(0, min(i - anchor_off, total - n))
+        win.set_seq1("\n".join(file_lines[start:start + n]))
+        r = win.ratio()
+        if r > best_ratio:
+            best_ratio, best_start = r, start
+    if best_start is None or best_ratio < 0.5:
+        return None
+    lo = max(0, best_start - context)
+    hi = min(total, best_start + n + context)
+    return lo + 1, hi, "\n".join(file_lines[lo:hi]), best_ratio
+
+
+_REGION_CAP = 4000
+
+
+def _not_found_payload(near, file_label: str) -> str:
+    """Render a _closest_region result as an error-message appendix. The
+    region text is emitted verbatim (no indentation) so it can be copied
+    straight into a retry old_string."""
+    if not near:
+        return ""
+    lo, hi, region, ratio = near
+    region = _display_safe(region)
+    if len(region) > _REGION_CAP:
+        region = (region[:_REGION_CAP]
+                  + f"\n⟦trimmed — run c3_read(file_path='{file_label}', "
+                  f"lines=[{lo},{hi}]) for the rest⟧")
+    return (f"\n  closest match: L{lo}-L{hi} ({ratio:.0%} similar). "
+            f"Actual file text between the markers:\n"
+            f"⟦L{lo}-L{hi}⟧\n{region}\n⟦end⟧\n"
+            f"  Retry with old_string copied exactly from the text above "
+            f"(markers excluded) — no need to re-read the file.")
+
+
 def handle_edit(file_path: str, old_string: str, new_string: str,
                 summary: str, tags: str, replace_all: bool,
                 svc, finalize, edits: str = "") -> str:
@@ -209,8 +304,10 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
                                 f"Read error: {e}", "read error")
 
             results = []
+            statuses = []   # parallel to results: 'ok' | 'miss' | 'ambiguous' | 'skipped'
             any_normalized = False
             any_applied = False
+            first_miss = ""
             for i, patch in enumerate(edit_list):
                 old = patch.get("old_string", "")
                 new = patch.get("new_string", "")
@@ -219,15 +316,23 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
 
                 if not old:
                     results.append(f"  patch[{i}]: skipped — empty old_string")
+                    statuses.append("skipped")
                     continue
 
                 new_content, count, used_fallback = _apply_replacement(content, old, new, r_all)
                 if new_content is None and count == 0:
-                    results.append(f"  patch[{i}]: NOT FOUND — {old[:80]!r}")
+                    near = _closest_region(content, old)
+                    loc = (f" (closest: L{near[0]}-L{near[1]}, {near[3]:.0%} similar)"
+                           if near else "")
+                    results.append(f"  patch[{i}]: NOT FOUND — {old[:80]!r}{loc}")
+                    statuses.append("miss")
+                    if near and not first_miss:
+                        first_miss = _not_found_payload(near, file_path)
                     continue
                 if new_content is None:
                     tag = " (unicode-normalized)" if used_fallback else ""
                     results.append(f"  patch[{i}]: AMBIGUOUS ({count} matches){tag} — {old[:60]!r}")
+                    statuses.append("ambiguous")
                     continue
 
                 content = new_content
@@ -243,6 +348,7 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
                                 + (f" ({n}x)" if n > 1 else "")
                                 + (" [norm]" if used_fallback else "")
                                 + f" | {desc}")
+                statuses.append("ok")
 
             # Only touch the file when at least one patch actually changed it —
             # avoids rewriting (and re-EOL-normalizing) an unchanged file and
@@ -266,12 +372,17 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
             ]}
             _log_to_ledger(rel, summary or f"Batch edit: {len(edit_list)} patches", tag_list, svc, detail=batch_detail)
 
-        applied = sum(1 for r in results if "NOT FOUND" not in r and "AMBIGUOUS" not in r and "skipped" not in r)
+        # Classify from the structured status list, not by substring-scanning
+        # the human-readable result lines — a patch *summary* containing words
+        # like 'NOT FOUND' used to be miscounted as a failure.
+        applied = statuses.count("ok")
         norm_tag = " [unicode-normalized]" if any_normalized else ""
         short = f"✓ {rel} — {applied}/{len(edit_list)} patches applied{norm_tag}"
         if applied < len(edit_list):
-            failed = [r for r in results if "NOT FOUND" in r or "AMBIGUOUS" in r or "skipped" in r]
+            failed = [r for r, s in zip(results, statuses) if s != "ok"]
             short += "\n" + "\n".join(failed)
+            if first_miss:
+                short += first_miss
         return finalize("c3_edit", {"file": file_path}, short,
                         f"{rel} patched ({len(edit_list)} patches)")
 
@@ -293,6 +404,7 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
             hint = ""
             if _norm(old_string) != old_string or _norm(content) != content:
                 hint = "\n  hint: unicode-lookalike normalization also failed to match."
+            hint += _not_found_payload(_closest_region(content, old_string), file_path)
             return finalize("c3_edit", {"file": file_path},
                             f"old_string not found in {file_path}\n"
                             f"  searched for: {old_string[:120]!r}{hint}",

{code_context_control-2.49.2 → code_context_control-2.50.0}/cli/tools/read.py

@@ -172,7 +172,14 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         pass
 
     raw_text = full.read_text(encoding="utf-8", errors="replace")
-    content_lines = raw_text.splitlines()
+    # EOL-normalize exactly the way c3_edit's matcher does (\r\n and \r → \n),
+    # then split on \n ONLY. splitlines() also breaks on \x0c/\u2028/\x85 etc.,
+    # which rendered those in-line chars as line breaks — an old_string copied
+    # from that output (with \n) could never match the actual file bytes.
+    raw_text = raw_text.replace("\r\n", "\n").replace("\r", "\n")
+    content_lines = raw_text.split("\n")
+    if content_lines and content_lines[-1] == "":
+        content_lines.pop()  # trailing \n would otherwise add a phantom empty line
     # Lazy: only count full file tokens when needed for the summary string
     _full_tok_cache = [None]
 
@@ -254,8 +261,9 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
 
     if not ranges:
         file_map = svc.file_memory.get_or_build_map(rel_path)
-        map_tok = count_tokens(file_map)
-        resp = file_map
+        resp = (file_map
+                + "\n[map only — pass lines=[start,end] or symbols=[...] for exact source]")
+        map_tok = count_tokens(resp)
         return finalize_with_tokens(
             finalize, svc, "c3_read", {"file": file_path},
             resp, f"{full_file_tokens()}->{map_tok}tok",
@@ -278,13 +286,23 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         header = f"[read:{file_path}]"
 
     parts = []
+    prev_end = None
     for start, end in ranges:
         s_idx = max(0, start - 1)
         e_idx = min(len(content_lines), end)
         chunk = content_lines[s_idx:e_idx]
         if len(ranges) > 1:
-            parts.append(f"--- L{start}-L{end} ---")
+            # ⟦…⟧ markers are tool chrome, not file content. The gap note makes
+            # the discontinuity explicit so a copied old_string never spans it.
+            if prev_end is None:
+                parts.append(f"⟦L{start}-L{end}⟧")
+            else:
+                parts.append(
+                    f"⟦L{start}-L{end} — {start - prev_end - 1} lines "
+                    f"(L{prev_end + 1}-L{start - 1}) omitted; blocks are NOT "
+                    f"contiguous, never span this marker in a c3_edit old_string⟧")
         parts.extend(chunk)
+        prev_end = end
 
     final_content = "\n".join(parts)
     tokens = count_tokens(final_content)

{code_context_control-2.49.2 → code_context_control-2.50.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.49.2
+Version: 2.50.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.49.2 → code_context_control-2.50.0}/code_context_control.egg-info/SOURCES.txt

@@ -267,6 +267,7 @@ tests/test_project_manager.py
 tests/test_project_manager_merge.py
 tests/test_project_tool.py
 tests/test_read_coercion.py
+tests/test_read_edit_parity.py
 tests/test_response_boilerplate.py
 tests/test_retention.py
 tests/test_review_digest.py

{code_context_control-2.49.2 → code_context_control-2.50.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.49.2"
+version = "2.50.0"
 description = "Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP)."
 readme = "README.md"
 requires-python = ">=3.10"

code_context_control-2.50.0/tests/test_read_edit_parity.py

@@ -0,0 +1,208 @@
+"""Parity tests between c3_read output and c3_edit matching.
+
+Regression suite for the read→edit drift bug: old_strings copied from
+c3_read output failed to match in c3_edit (encoding asymmetry, splitlines()
+unicode line-boundary splitting, separator pollution), pushing agents back
+to native Read/Edit. These tests pin the unified pipeline:
+
+- read: EOL-only normalization, form feeds/U+2028 stay inline,
+  copy-safe ⟦…⟧ range markers with explicit gap notes, map-hint footer.
+- edit: surrogateescape round-trip for non-UTF-8 bytes, U+FFFD match
+  folding, closest-region payload on not-found.
+"""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from cli.tools.edit import _closest_region, handle_edit  # noqa: E402
+from cli.tools.read import handle_read  # noqa: E402
+
+
+def _make_svc(project_path: Path):
+    svc = MagicMock()
+    svc.project_path = str(project_path)
+    svc.edit_ledger = None
+    svc.activity_log = None
+    svc.session_mgr = None
+    return svc
+
+
+def _finalize(name, args, resp, summ, **kw):
+    return resp
+
+
+class _Base(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.svc = _make_svc(self.root)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _write_text(self, rel: str, text: str) -> Path:
+        p = self.root / rel
+        p.write_text(text, encoding="utf-8", newline="")
+        return p
+
+    def _write_bytes(self, rel: str, data: bytes) -> Path:
+        p = self.root / rel
+        p.write_bytes(data)
+        return p
+
+    def _read(self, rel: str, **kw) -> str:
+        return handle_read(rel, svc=self.svc, finalize=_finalize, **kw)
+
+    def _edit(self, rel: str, old: str, new: str, **kw) -> str:
+        return handle_edit(rel, old, new, summary="", tags="",
+                           replace_all=kw.pop("replace_all", False),
+                           svc=self.svc, finalize=_finalize, **kw)
+
+
+class TestReadEolParity(_Base):
+    def test_form_feed_stays_inline(self):
+        # splitlines() used to break on \x0c, showing a phantom line break
+        # that made copied old_strings unmatchable.
+        self._write_text("a.py", "alpha\x0cbeta\ngamma\n")
+        resp = self._read("a.py", lines=[1, 2])
+        self.assertIn("alpha\x0cbeta", resp)
+        self.assertIn("gamma", resp)
+
+    def test_u2028_stays_inline(self):
+        self._write_text("b.py", "one\u2028two\nthree\n")
+        resp = self._read("b.py", lines=[1, 2])
+        self.assertIn("one\u2028two", resp)
+
+    def test_crlf_normalized_to_lf(self):
+        self._write_bytes("c.py", b"line1\r\nline2\r\n")
+        resp = self._read("c.py", lines=[1, 2])
+        self.assertNotIn("\r", resp)
+        self.assertIn("line1\nline2", resp)
+
+    def test_read_snippet_roundtrips_through_edit(self):
+        # The core parity guarantee: any snippet of c3_read output (single
+        # range) must match verbatim as a c3_edit old_string.
+        self._write_bytes("d.py", b"def f():\r\n    return 1\r\n")
+        resp = self._read("d.py", lines=[1, 2])
+        self.assertIn("def f():\n    return 1", resp)
+        edit_resp = self._edit("d.py", "def f():\n    return 1",
+                               "def f():\n    return 2")
+        self.assertIn("✓", edit_resp)  # ✓
+        self.assertEqual((self.root / "d.py").read_bytes(),
+                         b"def f():\r\n    return 2\r\n")
+
+
+class TestReadRangeMarkers(_Base):
+    def setUp(self):
+        super().setUp()
+        self._write_text("m.py",
+                         "".join(f"line{i}\n" for i in range(1, 13)))
+
+    def test_multi_range_has_gap_note(self):
+        resp = self._read("m.py", lines=[[1, 2], [8, 9]])
+        self.assertIn("⟦L1-L2⟧", resp)          # ⟦L1-L2⟧
+        self.assertIn("omitted", resp)
+        self.assertIn("L3-L7", resp)                       # the gap range
+        self.assertNotIn("--- L", resp)                    # old separator gone
+
+    def test_single_range_has_no_marker(self):
+        resp = self._read("m.py", lines=[1, 3])
+        self.assertNotIn("⟦", resp)
+
+
+class TestReadMapHint(_Base):
+    def test_map_response_says_how_to_get_source(self):
+        self._write_text("n.py", "x = 1\n")
+        self.svc.file_memory.get_or_build_map.return_value = "FILE MAP"
+        resp = self._read("n.py")
+        self.assertIn("FILE MAP", resp)
+        self.assertIn("map only", resp)
+        self.assertIn("lines=[start,end]", resp)
+
+
+class TestEditByteSafety(_Base):
+    LATIN1 = b"# caf\xe9 latin-1 comment\nvalue = 1\n"
+
+    def test_edit_succeeds_despite_invalid_utf8(self):
+        # Strict decode used to raise UnicodeDecodeError before matching.
+        self._write_bytes("e.py", self.LATIN1)
+        resp = self._edit("e.py", "value = 1", "value = 2")
+        self.assertIn("✓", resp)
+
+    def test_untouched_invalid_bytes_roundtrip(self):
+        self._write_bytes("e.py", self.LATIN1)
+        self._edit("e.py", "value = 1", "value = 2")
+        data = (self.root / "e.py").read_bytes()
+        self.assertIn(b"caf\xe9", data)          # byte preserved, not U+FFFD'd
+        self.assertIn(b"value = 2", data)
+
+    def test_fffd_from_read_output_matches_raw_byte(self):
+        # c3_read renders \xe9 as U+FFFD; that old_string must still match.
+        self._write_bytes("e.py", self.LATIN1)
+        resp = self._edit("e.py", "# caf� latin-1 comment", "# cafe comment")
+        self.assertIn("✓", resp)
+        self.assertNotIn(b"\xe9", (self.root / "e.py").read_bytes())
+
+
+class TestEditClosestRegion(_Base):
+    SRC = ("def foo(a, b):\n"
+           "    return compute(a, b)\n"
+           "\n"
+           "def bar():\n"
+           "    return 2\n")
+
+    def test_not_found_includes_closest_region(self):
+        self._write_text("f.py", self.SRC)
+        resp = self._edit("f.py", "    return compute(a, c)", "    return 0")
+        self.assertIn("not found", resp)
+        self.assertIn("closest match", resp)
+        self.assertIn("return compute(a, b)", resp)   # actual file text
+        self.assertIn("no need to re-read", resp)
+
+    def test_wildly_wrong_old_string_gets_no_region(self):
+        self._write_text("f.py", self.SRC)
+        resp = self._edit("f.py", "zzz@@qq##www!!", "x")
+        self.assertIn("not found", resp)
+        self.assertNotIn("closest match", resp)
+
+    def test_batch_miss_carries_locator_and_region(self):
+        self._write_text("f.py", self.SRC)
+        resp = handle_edit(
+            "f.py", "", "", summary="", tags="", replace_all=False,
+            svc=self.svc, finalize=_finalize,
+            edits='[{"old_string":"    return 2","new_string":"    return 3"},'
+                  '{"old_string":"    return compute(a, c)","new_string":"    return 0"}]',
+        )
+        self.assertIn("1/2 patches applied", resp)
+        self.assertIn("NOT FOUND", resp)
+        self.assertIn("closest:", resp)
+        self.assertIn("return compute(a, b)", resp)
+
+    def test_batch_summary_words_not_miscounted(self):
+        # Regression: patch summaries containing 'NOT FOUND'/'skipped' were
+        # substring-matched by the outcome classifier and reported as failures.
+        self._write_text("f.py", self.SRC)
+        resp = handle_edit(
+            "f.py", "", "", summary="", tags="", replace_all=False,
+            svc=self.svc, finalize=_finalize,
+            edits='[{"old_string":"    return 2","new_string":"    return 3",'
+                  '"summary":"this mentions NOT FOUND and skipped"}]',
+        )
+        self.assertIn("1/1 patches applied", resp)
+
+    def test_closest_region_line_numbers(self):
+        near = _closest_region(self.SRC, "    return compute(a, c)")
+        self.assertIsNotNone(near)
+        lo, hi, region, ratio = near
+        self.assertLessEqual(lo, 2)
+        self.assertGreaterEqual(hi, 2)
+        self.assertIn("return compute(a, b)", region)
+        self.assertGreater(ratio, 0.8)
+
+
+if __name__ == "__main__":
+    unittest.main()