code-context-control 2.121.0__tar.gz → 2.122.0__tar.gz

{code_context_control-2.121.0/code_context_control.egg-info → code_context_control-2.122.0}/PKG-INFO

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

{code_context_control-2.121.0 → code_context_control-2.122.0}/cli/commands/common.py

@@ -72,7 +72,7 @@ def cmd_index(args, deps: CommandDeps):
 def cmd_compress(args, deps: CommandDeps):
     """Compress a file and show results."""
     config = deps.load_config()
-    mode = args.mode or "smart"
+    mode = args.mode or "map"
 
     compressor = deps.CodeCompressor(str(Path(config.get("project_path", ".")) / ".c3/cache"))
     result = compressor.compress_file(args.file, mode)

{code_context_control-2.121.0 → code_context_control-2.122.0}/cli/commands/parser.py

@@ -91,7 +91,8 @@ def build_parser(version: str, parse_cli_ide_arg):
 
     p_compress = subparsers.add_parser("compress", help="Compress a file")
     p_compress.add_argument("file", help="File to compress")
-    p_compress.add_argument("--mode", choices=["map", "dense_map", "smart", "diff"], default="smart")
+    p_compress.add_argument("--mode", choices=["map", "smart", "structure", "outline"], default="map",
+                            help="map (default) is the canonical file map; the others are signature summaries")
     p_compress.add_argument("--output", "-o", action="store_true", help="Show compressed output")
 
     p_context = subparsers.add_parser("context", help="Get relevant context for a query")

code_context_control-2.122.0/cli/tools/compress.py

@@ -0,0 +1,251 @@
+"""c3_compress — the canonical file map (services/file_map.render_map), one file or a batch.
+
+There is one mode, `map`, and it is the same text c3_read(file_path) serves.
+The modes that existed before 2.122.0 (dense_map, smart, diff, bug_scan,
+ast, structure, outline) were called twice in 3,932 tool calls; a request
+for one of them is answered with the map plus a one-line notice so an old
+prompt keeps working while it says so (docs/file-map.md § Retired modes).
+"""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from cli.tools import _grants
+from cli.tools._helpers import finalize_with_tokens, show_token_ratios
+from core import count_tokens
+from services import access_guard
+
+#: Every mode name c3_compress ever accepted, and what to say about it now.
+RETIRED_MODES = {
+    "dense_map": "the map is dense now",
+    "smart": "the map carries full signatures",
+    "structure": "the map carries full signatures",
+    "outline": "the map carries full signatures",
+    "diff": "use `git diff` or the edit ledger (c3_edits)",
+    "bug_scan": "use c3_search(action='exact', query='except ') for handler hotspots",
+    "ast": "project architecture: codebase-memory-mcp `cli get_architecture`, or c3_status",
+}
+RETIRED_IN = "2.122.0"
+
+
+def deprecation_line(requested: str) -> str:
+    hint = RETIRED_MODES.get(requested, "")
+    return (f"[compress:deprecated] mode '{requested}' retired in {RETIRED_IN} — "
+            f"map is the only mode ({hint}); see docs/file-map.md")
+
+
+def map_detail(svc, rel: str, requested_mode: str, *, cache_hit: bool,
+               symbols: int = 0, fallback: str = "") -> dict:
+    """Telemetry `detail` for a map served from file_memory (C0, 2.120.0).
+
+    backend names the code path, parser the extractor that built the record
+    (tree_sitter | regex | generic, "" for a pre-2.120.0 record), cache_hit
+    whether the record was already fresh. `symbols` is how many the caller
+    asked for and `fallback` why a read served a map instead of source.
+    `deprecated_mode` (2.122.0) is set when a retired mode name was asked for.
+    Flat so telemetry.aggregate_tool_telemetry can fold it without a schema.
+    """
+    record = None
+    try:
+        record = svc.file_memory.get(rel)
+    except Exception:
+        record = None
+    if not isinstance(record, dict):
+        record = None
+    detail = {
+        "requested_mode": requested_mode,
+        "backend": "file_memory",
+        "parser": str((record or {}).get("parser") or ""),
+        "cache_hit": bool(cache_hit),
+        "sections": len((record or {}).get("sections") or []),
+    }
+    if symbols:
+        detail["symbols"] = int(symbols)
+    if fallback:
+        detail["fallback"] = fallback
+    if requested_mode not in ("map", "read"):
+        detail["deprecated_mode"] = requested_mode
+    return detail
+
+
+def handle_compress(file_path: str, mode: str, svc,
+                    finalize, maybe_facts) -> str:
+    requested = (mode or "map").strip() or "map"
+    if requested != "map" and requested not in RETIRED_MODES:
+        return finalize("c3_compress", {"file_path": file_path, "mode": requested},
+                        f"[compress:error] Unknown mode '{requested}'. The only mode is 'map'.",
+                        "error")
+    note = deprecation_line(requested) if requested != "map" else ""
+
+    # Batch dispatch: comma-separated paths
+    if "," in file_path:
+        paths = [p.strip() for p in file_path.split(",") if p.strip()]
+        return _compress_batch(paths, requested, note, svc, finalize)
+
+    return _compress_single(file_path, requested, note, svc, finalize)
+
+
+def _build_map(svc, rel: str) -> str:
+    """The canonical map for `rel`, draining any queued watcher updates first."""
+    queued = svc.file_memory.drain_queue()
+    completed = []
+    failed = []
+    for qp in queued[:10]:
+        try:
+            if svc.file_memory.update(qp):
+                completed.append(qp)
+            else:
+                failed.append(qp)
+        except Exception:
+            failed.append(qp)
+    if completed:
+        svc.file_memory.complete_updates(completed)
+    if failed:
+        svc.file_memory.complete_updates(failed, failed=True)
+    return svc.file_memory.get_or_build_map(rel)
+
+
+def _compress_single(file_path: str, requested: str, note: str, svc, finalize) -> str:
+    """Map a single file."""
+    # Access Guard: read verdict up front (docs/access-guard.md §3).
+    _verdict = access_guard.verdict(file_path, "read", svc.project_path)
+    if _verdict.denial and not _grants.allow(svc, _verdict.denial,
+                                             tool="c3_compress", op="read",
+                                             path=file_path):
+        return finalize("c3_compress", {"file_path": file_path, "mode": requested},
+                        access_guard.refusal(_verdict.denial, file_path, "read"),
+                        "access-denied")
+    # Mask Guard: the map is built through file_memory, which reads the RAW
+    # file — a masked path is served from its view instead
+    # (docs/mask-guard.md §6, row 7).
+    if _verdict.masked:
+        from services import mask_mirror
+        try:
+            view = mask_mirror.render_for_path(file_path, svc.project_path)
+        except mask_mirror.MaskUnavailable as exc:
+            return finalize("c3_compress",
+                            {"file_path": file_path, "mode": requested},
+                            f"{access_guard.TAG_MASK_UNSUPPORTED} {exc.message}",
+                            "mask-unavailable")
+        return finalize("c3_compress", {"file_path": file_path, "mode": requested},
+                        view.with_header(file_path), f"masked:{view.preset}")
+
+    full = Path(svc.project_path) / file_path
+    if not full.exists():
+        full = Path(file_path)
+    if not full.exists():
+        return ("[file_map:error] not found. To create a new file use "
+                "c3_edit(file_path=..., old_string='', new_string=<content>).")
+    rel = str(full.resolve().relative_to(Path(svc.project_path).resolve())).replace("\\", "/")
+    # C0 measurement: was the record already fresh before this call?
+    cache_hit = not svc.file_memory.needs_update(rel)
+    res = _build_map(svc, rel)
+    raw_tokens = None
+    map_tokens = 0
+    try:
+        raw_text = full.read_text(encoding="utf-8", errors="replace")
+        raw_tokens = count_tokens(raw_text)
+        map_tokens = count_tokens(res)
+        if map_tokens >= raw_tokens and not res.startswith("[file_map]"):
+            # A map that costs more than the file is worth nothing
+            # (docs/file-map.md § Small files).
+            res = f"[compress:{file_path}] whole file — smaller than its map\n" + raw_text
+            map_tokens = count_tokens(res)
+        summary = "map"
+    except Exception:
+        summary = "mapped"
+    if note:
+        res = note + "\n" + res
+        map_tokens = count_tokens(res)
+    return finalize_with_tokens(
+        finalize, svc, "c3_compress", {"file_path": file_path, "mode": requested},
+        res, summary,
+        raw_tokens=raw_tokens, optimized_tokens=map_tokens or None,
+        response_tokens=map_tokens,
+        detail=map_detail(svc, rel, requested, cache_hit=cache_hit))
+
+
+def _compress_batch(paths: list, requested: str, note: str, svc, finalize) -> str:
+    """Map several files in parallel, return one combined report."""
+    max_files = 10
+    paths = paths[:max_files]
+
+    results = {}
+
+    def _do_one(fp):
+        """Returns (fp, map_text, raw_tokens, map_tokens, error)."""
+        try:
+            # Access Guard: per-member read verdict — the S1 refusal becomes
+            # this member's batch line; other members are still served.
+            _v = access_guard.verdict(fp, "read", svc.project_path)
+            if _v.denial:
+                return fp, None, None, None, access_guard.refusal(_v.denial, fp,
+                                                                  "read")
+            if _v.masked:
+                from services import mask_mirror
+                try:
+                    view = mask_mirror.render_for_path(fp, svc.project_path)
+                except mask_mirror.MaskUnavailable as exc:
+                    return fp, None, None, None, \
+                        f"{access_guard.TAG_MASK_UNSUPPORTED} {exc.message}"
+                text = view.with_header(fp)
+                return fp, text, None, count_tokens(text), None
+            full = Path(svc.project_path) / fp
+            if not full.exists():
+                full = Path(fp)
+            if not full.exists():
+                return fp, None, None, None, "not found"
+            rel = str(full.resolve().relative_to(
+                Path(svc.project_path).resolve())).replace("\\", "/")
+            res = svc.file_memory.get_or_build_map(rel)
+            try:
+                raw_tok = count_tokens(full.read_text(encoding="utf-8", errors="replace"))
+                map_tok = count_tokens(res)
+                return fp, res, raw_tok, map_tok, None
+            except Exception:
+                return fp, res, None, None, None
+        except Exception as e:
+            return fp, None, None, None, str(e)
+
+    with ThreadPoolExecutor(max_workers=min(len(paths), 8)) as pool:
+        futures = {pool.submit(_do_one, fp): fp for fp in paths}
+        for fut in as_completed(futures):
+            fp, text, raw_tok, opt_tok, err = fut.result()
+            results[fp] = (text, raw_tok, opt_tok, err)
+
+    ratios = show_token_ratios(svc)
+    parts = []
+    total_ok = 0
+    total_raw = 0
+    total_opt = 0
+    measured = 0
+    for fp in paths:
+        text, raw_tok, opt_tok, err = results.get(fp, (None, None, None, "unknown"))
+        if text:
+            tag = ""
+            if raw_tok is not None and opt_tok is not None:
+                measured += 1
+                total_raw += raw_tok
+                total_opt += opt_tok
+                if ratios:
+                    tag = f" ({raw_tok}->{opt_tok}tok)"
+            parts.append(f"## {fp}{tag}\n{text}")
+            total_ok += 1
+        else:
+            parts.append(f"## {fp} — ERROR: {err}")
+
+    header = f"[compress:batch] {total_ok}/{len(paths)} files (map)"
+    if note:
+        header = note + "\n" + header
+    body = header + "\n\n" + "\n\n".join(parts)
+    detail = {"requested_mode": requested, "backend": "batch",
+              "files": len(paths), "ok": total_ok}
+    if requested != "map":
+        detail["deprecated_mode"] = requested
+    return finalize_with_tokens(
+        finalize, svc, "c3_compress",
+        {"file_path": ",".join(paths), "mode": requested, "batch": True},
+        body, f"batch {total_ok}/{len(paths)}",
+        raw_tokens=total_raw if measured else None,
+        optimized_tokens=total_opt if measured else None,
+        detail=detail)

{code_context_control-2.121.0 → code_context_control-2.122.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.121.0
+Version: 2.122.0
 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.121.0 → code_context_control-2.122.0}/pyproject.toml

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

@@ -2,10 +2,12 @@
 AST-based Code Compression Service
 
 Parses source files into AST and generates compressed summaries:
-- Function/class signatures only (skip bodies)
-- Structural outline mode
-- Smart truncation with context preservation
-- Diff-only mode for edits
+- "map": the canonical file map (services/file_map) — what the tools serve
+- "structure" / "outline" / "smart": signature-only summaries kept for
+  internal callers (delegate, Hub REST, context snapshots, benchmarks)
+- "summary": an LLM summary through the router, when one is configured
+
+"diff" and "bug_scan" were retired in 2.122.0 (docs/file-map.md).
 """
 import hashlib
 import json
@@ -145,6 +147,30 @@ class CodeCompressor:
         if protected_files:
             self._protected_files.update(self._normalize_rel_path(p) for p in protected_files)
         self.router = router
+        self._sweep_retired_caches()
+
+    #: Modes the compressor no longer implements, and where to go instead.
+    RETIRED_MODES = {
+        "diff": "use `git diff` or the edit ledger",
+        "bug_scan": "use c3_search(action='exact', query='except ')",
+        "dense_map": "use mode='map'",
+    }
+
+    def _sweep_retired_caches(self) -> int:
+        """Delete the pre-2.122.0 diff caches: one full copy of every file
+        ever diffed, keyed by BASENAME (so every __init__.py collided).
+        Cheap — only diff wrote `*.cache`; after one sweep there are none."""
+        removed = 0
+        try:
+            for f in self.cache_dir.glob("*.cache"):
+                try:
+                    f.unlink()
+                    removed += 1
+                except OSError:
+                    continue
+        except Exception:
+            pass
+        return removed
 
     @staticmethod
     def _normalize_rel_path(path: str) -> str:
@@ -192,13 +218,17 @@ class CodeCompressor:
         Compress a source file.
 
         Modes:
+        - "map": the canonical file map (services/file_map.render_map)
         - "structure": Function/class signatures + imports (most compressed)
         - "outline": Structure + docstrings + key comments
         - "smart": Adaptive - more detail for small files, less for large
-        - "diff": Only changes since last seen (requires prior state)
         - "summary": High-level LLM summary (requires router)
-        - "bug_scan": Structure map + annotated exception-handling hotspots with line numbers
+        Retired (2.122.0): "diff", "bug_scan", "dense_map" -> error dict.
         """
+        if mode in self.RETIRED_MODES:
+            return {"error": f"mode '{mode}' retired in 2.122.0 — "
+                             f"{self.RETIRED_MODES[mode]} (docs/file-map.md)",
+                    "compressed": "", "retired": True}
         # Access Guard: read verdict before any cache or disk access — denied
         # paths raise AccessDenied (docs/access-guard.md §3). Callers that
         # need string returns catch it and surface exc.message. Checked
@@ -241,8 +271,9 @@ class CodeCompressor:
         content_hash = hashlib.md5(content.encode()).hexdigest()
         ext = filepath.suffix.lower()
 
-        # Check persistent cache (except for diff/summary which have their own logic)
-        if mode not in ("diff", "summary"):
+        # Check persistent cache (summary has its own logic; map is served
+        # from file_memory's own cache below)
+        if mode not in ("summary", "map"):
             cache_key = f"{content_hash}_{mode}{ext}.json"
             if mask_view is not None:
                 cache_key = f"mask-{mask_view.view_hash}_{cache_key}"
@@ -271,7 +302,10 @@ class CodeCompressor:
         # entries (keyed on content hash) still win. diff/summary are exempt:
         # diff is the recommended targeted alternative and summary delegates
         # to the router.
-        if mode not in ("diff", "summary"):
+        if mode == "map":
+            return self._canonical_map(filepath, content)
+
+        if mode != "summary":
             line_count = content.count("\n")
             if content and not content.endswith("\n"):
                 line_count += 1
@@ -285,9 +319,6 @@ class CodeCompressor:
                     filepath, content, content_hash, ext, mode,
                     byte_size, line_count)
 
-        if mode == "diff":
-            return self._diff_compress(filepath, content)
-
         if mode == "summary":
             if not self.router:
                 return {"error": "Summary mode requires a router", "compressed": ""}
@@ -296,31 +327,6 @@ class CodeCompressor:
             result = f"# {filepath.name} — SUMMARY\n{summary}"
             return {"compressed": result, "mode": "summary", **measure_savings(content, result)}
 
-        if mode == "bug_scan":
-            # Structure map + exception-handling annotation pass
-            structure = self._extract_structure(content, ext, "outline")
-            exception_section = self._scan_exception_handlers(content)
-            compressed_parts = [structure]
-            if exception_section:
-                compressed_parts.append(exception_section)
-            compressed = "\n".join(compressed_parts)
-            header = f"# {filepath.name} ({filepath.suffix}) — {len(content.splitlines())} lines [bug_scan]\n"
-            result = header + compressed
-            savings = measure_savings(content, result)
-            savings["compressed"] = result
-            savings["mode"] = "bug_scan"
-            savings["filepath"] = str(filepath)
-            self._file_hashes[str(filepath)] = content_hash
-            cache_key = f"{content_hash}_bug_scan{ext}.json"
-            self._mem_cache[cache_key] = dict(savings)
-            cache_file = self.cache_dir / cache_key
-            try:
-                with open(cache_file, "w", encoding="utf-8") as f:
-                    json.dump(savings, f, indent=2)
-            except Exception:
-                pass
-            return savings
-
         if mode == "smart":
             tokens = count_tokens(content)
             if tokens < 80:
@@ -354,8 +360,8 @@ class CodeCompressor:
         # Cache hash for diff mode
         self._file_hashes[str(filepath)] = content_hash
 
-        # Persist to cache (except diff which uses its own file format)
-        if mode not in ("diff", "summary"):
+        # Persist to cache
+        if mode != "summary":
             cache_key = f"{content_hash}_{mode}{ext}.json"
             # Store in memory first (fast path for repeat access)
             if len(self._mem_cache) >= self._MEM_CACHE_MAX:
@@ -648,51 +654,6 @@ class CodeCompressor:
 
         return None
 
-    def _scan_exception_handlers(self, content: str) -> str:
-        """Scan for exception-handling hotspots and return an annotated section.
-
-        Returns a formatted block listing every bare/broad except clause with:
-          - line number
-          - the except line itself
-          - the immediately enclosing function name (if detectable)
-
-        Returns an empty string if no exception handlers are found.
-        """
-        lines = content.splitlines()
-        # Patterns ranked from most to least problematic
-        _EXCEPT_PATTERNS = [
-            (re.compile(r"^\s*except\s*:"),          "bare-except"),
-            (re.compile(r"^\s*except\s+Exception\s*:"), "broad-except"),
-            (re.compile(r"^\s*except\s+Exception\s+as\s+\w+\s*:"), "broad-except"),
-            (re.compile(r"^\s*except\s+\("),          "multi-except"),
-        ]
-        _FUNC_DEF = re.compile(r"^\s*(?:async\s+)?def\s+(\w+)")
-
-        hits: list[str] = []
-        # Track the most recently seen function name for context
-        current_func = "<module>"
-        for idx, line in enumerate(lines, start=1):
-            m = _FUNC_DEF.match(line)
-            if m:
-                current_func = m.group(1)
-            for pattern, label in _EXCEPT_PATTERNS:
-                if pattern.match(line):
-                    # Show up to 2 continuation lines (body of the except block)
-                    body_lines = []
-                    for j in range(idx, min(idx + 2, len(lines))):
-                        body = lines[j].strip()
-                        if body and not body.startswith("except") and not body.startswith("try"):
-                            body_lines.append(body)
-                    body_preview = " | ".join(body_lines[:2]) if body_lines else ""
-                    suffix = f"  → {body_preview}" if body_preview else ""
-                    hits.append(f"  L{idx} [{label}] in `{current_func}`: {line.strip()}{suffix}")
-                    break  # one label per line
-
-        if not hits:
-            return ""
-        header = f"\n# Exception-handling hotspots ({len(hits)} found):"
-        return header + "\n" + "\n".join(hits)
-
     def _generic_compress(self, content: str, ext: str) -> str:
         """Fallback compression for unknown languages."""
         lines = content.split('\n')
@@ -712,49 +673,33 @@ class CodeCompressor:
                 kept.append(stripped)
         return '\n'.join(kept)
 
-    def _diff_compress(self, filepath: Path, current_content: str) -> dict:
-        """Generate diff-based compression against cached version."""
-        cache_file = self.cache_dir / f"{filepath.name}.cache"
-        current_hash = hashlib.md5(current_content.encode()).hexdigest()
+    def _canonical_map(self, filepath: Path, content: str) -> dict:
+        """mode="map": the same text c3_read / c3_compress serve.
 
-        if cache_file.exists():
-            cached = cache_file.read_text(encoding="utf-8", errors="replace")
-            cached_hash = hashlib.md5(cached.encode()).hexdigest()
-
-            if cached_hash == current_hash:
-                result = f"# {filepath.name} — NO CHANGES"
-                return {"compressed": result, "mode": "diff-unchanged", **measure_savings(current_content, result)}
-
-            # Generate contextual diff
-            diff = self._contextual_diff(cached.split('\n'), current_content.split('\n'), filepath.name)
-            savings = measure_savings(current_content, diff)
-            savings["compressed"] = diff
-            savings["mode"] = "diff"
-        else:
-            # No cache — fall back to structure mode
-            compressed = self._extract_structure(current_content, filepath.suffix.lower(), "structure")
-            header = f"# {filepath.name} (FIRST SEEN) — {len(current_content.splitlines())} lines\n"
-            result = header + compressed
-            savings = measure_savings(current_content, result)
-            savings["compressed"] = result
-            savings["mode"] = "diff-first"
-
-        # Update cache
-        cache_file.write_text(current_content, encoding="utf-8")
+        Built from a throwaway FileMemoryStore-style extraction so callers
+        that only hold a compressor (Hub REST, `c3 compress`, delegate)
+        get the canonical map rather than a structure-only summary.
+        """
+        from services.file_map import render_map
+        from services.file_memory import LANG_MAP, FileMemoryStore
+        ext = filepath.suffix.lower()
+        sections, parser = FileMemoryStore._extract_sections_with_parser(
+            FileMemoryStore.__new__(FileMemoryStore), filepath, content)
+        record = {
+            "path": self._relative_to_project(filepath),
+            "lines": len(content.splitlines()),
+            "language": LANG_MAP.get(ext, ext.lstrip(".")),
+            "parser": parser,
+            "sections": sections,
+        }
+        result = render_map(record)
+        savings = measure_savings(content, result)
+        savings["compressed"] = result
+        savings["mode"] = "map"
+        savings["parser"] = parser
+        savings["filepath"] = str(filepath)
         return savings
 
-    def _contextual_diff(self, old_lines: list, new_lines: list, filename: str) -> str:
-        """Generate a contextual diff with surrounding structure."""
-        import difflib
-        differ = difflib.unified_diff(old_lines, new_lines, lineterm='', n=1)
-        diff_text = '\n'.join(differ)
-
-        if not diff_text.strip():
-            return f"# {filename} — NO CHANGES"
-
-        header = f"# {filename} — CHANGES ONLY\n"
-        return header + diff_text
-
     def compress_directory(self, dirpath: str, mode: str = "smart",
                           extensions: Optional[list] = None,
                           max_files: int = 50) -> dict:

{code_context_control-2.121.0 → code_context_control-2.122.0}/tests/test_compressor_large_file.py

@@ -208,17 +208,27 @@ class TestLargeFileFastPath(unittest.TestCase):
 
     # ── mode exemptions ─────────────────────────────────────────────────
 
-    def test_diff_mode_not_intercepted(self):
-        # diff is the documented alternative for large files — it must keep
-        # its own path and never return the fast-path header.
+    def test_diff_mode_is_retired(self):
+        # diff was retired in 2.122.0: it cached full copies of every file
+        # keyed by basename. The answer is an error naming the replacement,
+        # never a fast-path header.
         content = _make_python_source(LARGE_FILE_LINE_THRESHOLD + 100, "dif")
         fpath = self._write("diffable.py", content)
 
         res = self.comp.compress_file(str(fpath), "diff")
 
+        self.assertTrue(res.get("retired"))
+        self.assertIn("retired in 2.122.0", res["error"])
         self.assertNotIn("fast_path", res)
-        self.assertTrue(res["mode"].startswith("diff"))
-        self.assertNotIn(LARGE_FILE_GUIDANCE, res["compressed"])
+
+    def test_map_mode_is_the_canonical_map_even_for_large_files(self):
+        content = _make_python_source(LARGE_FILE_LINE_THRESHOLD + 100, "mp")
+        fpath = self._write("mapbig.py", content)
+        res = self.comp.compress_file(str(fpath), "map")
+        self.assertEqual(res["mode"], "map")
+        self.assertNotIn("fast_path", res)
+        self.assertTrue(res["compressed"].startswith("# "))
+        self.assertIn("[L", res["compressed"])
 
     def test_smart_mode_takes_fast_path(self):
         content = _make_python_source(LARGE_FILE_LINE_THRESHOLD + 100, "smt")

{code_context_control-2.121.0 → code_context_control-2.122.0}/tests/test_map_telemetry_c0.py

@@ -140,18 +140,18 @@ class TestCompressDetail(unittest.TestCase):
             self.assertEqual(rows[0]["target"], "pkg/mod.py")
             self.assertGreater(rows[0]["raw_tokens"], rows[0]["optimized_tokens"])
 
-    def test_compressor_mode_detail_and_cache_hit(self):
+    def test_retired_mode_detail(self):
         with tempfile.TemporaryDirectory() as tmp:
             svc = _project(tmp)
             fin = _finalize_via(svc.session_mgr)
-            handle_compress("pkg/mod.py", "smart", svc, fin, _no_facts)
-            handle_compress("pkg/mod.py", "smart", svc, fin, _no_facts)
+            out = handle_compress("pkg/mod.py", "smart", svc, fin, _no_facts)
+            self.assertTrue(out.startswith("[compress:deprecated] mode 'smart'"))
+            self.assertIn("C Thing [L", out)
             rows = [r["detail"] for r in _rows(tmp) if r["tool"] == "c3_compress"]
-            self.assertEqual(rows[0]["backend"], "compressor")
+            self.assertEqual(rows[0]["backend"], "file_memory")
             self.assertEqual(rows[0]["requested_mode"], "smart")
-            self.assertFalse(rows[0]["cache_hit"])
-            self.assertTrue(rows[1]["cache_hit"])
-            self.assertIn(rows[0]["actual_mode"], ("full", "outline", "structure", "smart"))
+            self.assertEqual(rows[0]["deprecated_mode"], "smart")
+            self.assertEqual(rows[0]["parser"], "tree_sitter")
 
     def test_batch_detail(self):
         with tempfile.TemporaryDirectory() as tmp: