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

{code_context_control-2.120.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.120.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.120.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.120.0"
+__version__ = "2.122.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):

{code_context_control-2.120.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.120.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.120.0 → code_context_control-2.122.0}/cli/mcp_server.py

@@ -85,7 +85,7 @@ def _build_instructions(ide_name: str) -> str:
     return (
         "C3 — local code intelligence. Route by goal:\n"
         "  FIND candidates → c3_search\n"
-        "  MAP file shape → c3_compress(mode='map') then READ content → c3_read(symbols=…)\n"
+        "  MAP a file → c3_read(file_path) with no symbols, then READ → c3_read(symbols=…); batch maps → c3_compress\n"
         "  EDIT code → c3_edit (always; it logs to the ledger automatically)\n"
         "  VALIDATE after every edit → c3_validate\n"
         "  BLAST RADIUS before shared-symbol edits → c3_impact\n"
@@ -583,8 +583,10 @@ async def c3_memory(action: str, query: str = "", fact: str = "",
 @mcp.tool()
 async def c3_read(file_path: str, symbols: Any = None, lines: Any = None,
             include_docstrings: bool = True, ctx: Context = None) -> str:
-    """READ exact content. Use after c3_compress when you need real source (read-only, plan-mode safe).
-    file_path: single or comma-separated. symbols: function/class names. lines: int, [start,end], or list of ranges."""
+    """READ source, or MAP a file when called with only file_path (read-only, plan-mode safe).
+    file_path: single or comma-separated. symbols: names as the map prints them (Class.method ok).
+    lines: int, [start,end], or list of ranges. No symbols/lines = one line per symbol with
+    signature and [La-Lb] range at ~10% of the file's tokens; then read the symbols you need."""
     path_err = validate_file_path(file_path)
     if path_err:
         return f"[c3_read:error] {path_err}"
@@ -597,10 +599,11 @@ async def c3_read(file_path: str, symbols: Any = None, lines: Any = None,
 
 
 @mcp.tool()
-async def c3_compress(file_path: str, mode: str = "smart", ctx: Context = None) -> str:
-    """MAP file shape — classes/functions/imports at 40-70% tokens (read-only, plan-mode safe).
-    Use before c3_read to know which symbols to fetch. Modes: map, dense_map, smart, diff, bug_scan, ast.
-    file_path: single or comma-separated."""
+async def c3_compress(file_path: str, mode: str = "map", ctx: Context = None) -> str:
+    """MAP a file — one line per symbol with full signature and [La-Lb] range, ~10% of the
+    file's tokens (read-only, plan-mode safe). Same map as c3_read(file_path) with no symbols;
+    use this form for a comma-separated batch (up to 10). mode: map (default); other modes
+    are legacy."""
     path_err = validate_file_path(file_path)
     if path_err:
         return f"[c3_compress:error] {path_err}"

{code_context_control-2.120.0 → code_context_control-2.122.0}/cli/tools/agent.py

@@ -877,11 +877,10 @@ def _parallel_compress(files: list, svc, steps_log: list,
     maps = {}
 
     def compress_one(fp):
-        full_path = str(Path(svc.project_path) / fp)
         try:
-            res = svc.compressor.compress_file(full_path, "map")
-            if isinstance(res, dict) and res.get("compressed"):
-                return fp, res["compressed"]
+            fmap = svc.file_memory.get_or_build_map(fp.replace("\\", "/"))
+            if fmap and not fmap.startswith("[file_map]"):
+                return fp, fmap
         except Exception:
             pass
         return fp, None
@@ -936,11 +935,10 @@ def _parallel_validate_and_compress(files: list, svc, steps_log: list):
             return "validate", fp, "ERROR", str(e)
 
     def compress_one(fp):
-        full_path = str(Path(svc.project_path) / fp)
         try:
-            res = svc.compressor.compress_file(full_path, "map")
-            if isinstance(res, dict) and res.get("compressed"):
-                return "compress", fp, res["compressed"]
+            fmap = svc.file_memory.get_or_build_map(fp.replace("\\", "/"))
+            if fmap and not fmap.startswith("[file_map]"):
+                return "compress", fp, fmap
         except Exception:
             pass
         return "compress", fp, None

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.120.0 → code_context_control-2.122.0}/cli/tools/read.py

@@ -316,6 +316,11 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
     if not ranges:
         map_cached = not svc.file_memory.needs_update(rel_path)
         file_map = svc.file_memory.get_or_build_map(rel_path)
+        if count_tokens(file_map) >= full_file_tokens():
+            # A map that costs more than the file is worth nothing: serve the
+            # file (docs/file-map.md § Small files).
+            file_map = (f"[read:{file_path}] whole file — smaller than its map\n"
+                        + raw_text)
         resp = (file_map
                 + "\n[map only — pass lines=[start,end] or symbols=[...] for exact source]"
                 + maybe_related_facts(svc, rel_path, top_k=3, context="read"))

{code_context_control-2.120.0 → code_context_control-2.122.0}/cli/tools/search.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from cli.tools._helpers import finalize_with_tokens, show_token_ratios
 from core import count_tokens
 from services import access_guard
+from services.file_map import render_map
 from services.indexer import DEFAULT_CODE_EXTS
 from services.lexical_index import Filters, doc_kind
 from services.scanner import SKIP_DIRS, iter_files
@@ -473,21 +474,15 @@ def _first_file_map(rel: str, svc) -> str:
         watcher_active = (hasattr(svc, "watcher") and svc.watcher._observer.is_alive())
         if not watcher_active and svc.file_memory.needs_update(rel):
             svc.file_memory.update(rel)
-        fmap = svc.file_memory.get_or_build_map(rel)
+        record = svc.file_memory.get(rel)
+        if not record:
+            return ""
+        # Same renderer as c3_read/c3_compress, shortened to the cap by
+        # dropping symbol lines from the end (docs/file-map.md).
+        fmap = render_map(record, max_tokens=_MAP_TOKEN_CAP)
         if not fmap:
             return ""
-        if count_tokens(fmap) <= _MAP_TOKEN_CAP:
-            return f"\n  {fmap.replace(chr(10), chr(10) + '  ')}"
-        # Truncate large maps: keep first N lines
-        truncated = []
-        tok = 0
-        for fl in fmap.split("\n"):
-            tok += count_tokens(fl)
-            if tok > _MAP_TOKEN_CAP:
-                break
-            truncated.append(fl)
-        truncated.append("  [map truncated]")
-        return f"\n  {chr(10).join(truncated).replace(chr(10), chr(10) + '  ')}"
+        return f"\n  {fmap.replace(chr(10), chr(10) + '  ')}"
     except Exception:
         return ""
 
@@ -720,11 +715,13 @@ def _append_prefetch(resp: str, query: str, top_k: int, svc) -> str:
         uncached.append(fp)
 
     def compress_one(fp):
+        # The canonical map from file_memory — the same text c3_read serves
+        # (compressor.compress_file never had a "map" mode; it rendered a
+        # structure-only summary under that name).
         try:
-            full = str(Path(svc.project_path) / fp)
-            result = svc.compressor.compress_file(full, "map")
-            if isinstance(result, dict) and result.get("compressed"):
-                return fp, result["compressed"]
+            fmap = svc.file_memory.get_or_build_map(fp.replace("\\", "/"))
+            if fmap and not fmap.startswith("[file_map]"):
+                return fp, fmap
         except Exception:
             pass
         return fp, None

{code_context_control-2.120.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.120.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.120.0 → code_context_control-2.122.0}/code_context_control.egg-info/SOURCES.txt

@@ -225,6 +225,7 @@ services/edit_ledger.py
 services/embedding_index.py
 services/enforcement_policy.py
 services/error_reporting.py
+services/file_map.py
 services/file_memory.py
 services/git_context.py
 services/hub_service.py
@@ -357,6 +358,7 @@ tests/test_enforcement_routes.py
 tests/test_env_parser.py
 tests/test_failed_calls_do_not_unlock.py
 tests/test_federated_graph.py
+tests/test_file_map_c1.py
 tests/test_filter_backoff.py
 tests/test_ghost_files.py
 tests/test_ghost_generation.py

{code_context_control-2.120.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.120.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.120.0 → code_context_control-2.122.0}/services/agents.py

@@ -923,29 +923,10 @@ class FileMemoryAgent(BackgroundAgent):
         completed = []
         failed = []
         for rel_path in files_to_process:
-            ai_summary = None
-
-            # Generate AI summary if available
-            if self.ai_available:
-                record = self.file_memory.get(rel_path)
-                section_names = ""
-                if record:
-                    names = [s.get("name", "") for s in record.get("sections", [])
-                             if s.get("type") not in ("import", "decorator")]
-                    section_names = ", ".join(names[:10])
-
-                if section_names:
-                    ai_summary = self._ai_generate(
-                        f"File: {rel_path}\n"
-                        f"Symbols: {section_names}\n\n"
-                        f"Describe the purpose of this file and its main symbols in 1-2 concise sentences. "
-                        f"Focus on what they do, not how they are implemented.",
-                        system="You are a senior architect summarizing code for an AI assistant. "
-                               "Be technical, concise, and highlight the main responsibilities of the symbols.",
-                        max_tokens=100,
-                    )
-
-            result = self.file_memory.update(rel_path, ai_summary=ai_summary)
+            # No generated summary: it was produced from symbol names alone
+            # and half of the stored ones were cut mid-sentence (2026-09-06).
+            # The map carries symbols and ranges only (docs/file-map.md).
+            result = self.file_memory.update(rel_path)
             if result:
                 updated_count += 1
                 completed.append(rel_path)