code-context-control 2.102.0__tar.gz → 2.110.0__tar.gz

{code_context_control-2.102.0 → code_context_control-2.110.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.102.0
+Version: 2.110.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
@@ -47,6 +47,8 @@ Provides-Extra: vector
 Requires-Dist: scikit-learn>=1.3.0; extra == "vector"
 Requires-Dist: numpy>=1.24.0; extra == "vector"
 Requires-Dist: chromadb>=0.4.24; extra == "vector"
+Provides-Extra: rerank
+Requires-Dist: flashrank>=0.2.10; extra == "rerank"
 Provides-Extra: tui
 Requires-Dist: textual>=0.50.0; extra == "tui"
 Provides-Extra: telemetry

{code_context_control-2.102.0 → code_context_control-2.110.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.102.0"
+__version__ = "2.110.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -591,21 +591,21 @@ def _check_c3_health(project_path: str) -> dict:
         issues.append(f"missing directories: {', '.join(missing_dirs)}")
         info["missing_dirs"] = missing_dirs
 
-    # Index presence and basic stats
-    index_file = c3_dir / "index" / "index.json"
-    if not index_file.exists():
-        issues.append("code index not built")
-        info["index_files"] = 0
-        info["index_chunks"] = 0
-    else:
-        try:
-            data = json.loads(index_file.read_text(encoding="utf-8"))
-            info["index_files"] = len(data.get("documents", {}))
-            info["index_chunks"] = len(data.get("chunks", {}))
-        except Exception:
-            issues.append("code index corrupt")
-            info["index_files"] = 0
-            info["index_chunks"] = 0
+    # Index presence and basic stats (services/index_store; index.json is
+    # the pre-2.107.0 layout and counts as "present, needs a rebuild").
+    try:
+        from services.index_store import IndexStore
+        store = IndexStore(c3_dir / "index")
+        n_docs, n_chunks = store.counts()
+    except Exception:
+        store, n_docs, n_chunks = None, 0, 0
+    info["index_files"] = n_docs
+    info["index_chunks"] = n_chunks
+    if n_docs == 0:
+        if (c3_dir / "index" / "index.json").exists():
+            issues.append("code index in the pre-2.107.0 layout; run `c3 index` to migrate")
+        else:
+            issues.append("code index not built")
 
     # Stale file changes (tracked by the watcher inside CodeIndex)
     # The watcher writes pending changes to .c3/index/changes.json
@@ -1500,6 +1500,42 @@ def cmd_stats(args):
     return common_cmd_stats(args, _command_deps())
 
 
+def cmd_search_eval(args):
+    """Run the c3_search relevance suite and compare it to its baseline.
+
+    Exit status 1 when the baseline is violated (a must_pass case failed, a
+    canary leaked, or an aggregate fell under its floor), so the command can
+    stand in a pre-push gate. See docs/search-eval.md.
+    """
+    from services.bench import search_eval as se
+
+    try:
+        report = se.run_suite(args.suite, repo=args.repo, rebuild=args.rebuild,
+                              semantic=args.semantic, baseline=args.baseline,
+                              rerank=getattr(args, "rerank", "off"))
+    except FileNotFoundError as e:
+        raise RuntimeError(str(e))
+
+    if args.update_baseline:
+        path = args.baseline or se.BUNDLED_BASELINES.get(report.suite)
+        if not path:
+            raise RuntimeError(
+                f"suite {report.suite!r} has no bundled baseline; pass --baseline PATH")
+        floors = json.loads(args.floors) if args.floors else None
+        se.write_baseline(report, path, floors=floors)
+        # Re-compare so the printed verdict reflects the file just written.
+        report.baseline_violations, report.baseline_warnings = se.compare_to_baseline(
+            report, se.load_baseline(path))
+        print(f"baseline written: {path}")
+
+    if args.json:
+        print(json.dumps(report.to_dict(), indent=2))
+    else:
+        print(report.render())
+    if report.baseline_violations:
+        sys.exit(1)
+
+
 def _benchmark_extract_preview(full_path: Path, compressor: CodeCompressor, pattern: str = "", max_lines: int = 50) -> str:
     """Approximate c3_filter behavior for local benchmarking without MCP startup."""
     import re as _re
@@ -9163,6 +9199,7 @@ def main():
         "claudemd": cmd_claudemd,
         "map": cmd_map,
         "stats": cmd_stats,
+        "search-eval": cmd_search_eval,
         "benchmark": cmd_benchmark,
         "session-benchmark": cmd_session_benchmark,
         "benchmark-e2e": cmd_benchmark_e2e,

{code_context_control-2.102.0 → code_context_control-2.110.0}/cli/commands/common.py

@@ -26,25 +26,48 @@ class CommandDeps:
 
 
 def cmd_index(args, deps: CommandDeps):
-    """Rebuild the code index."""
+    """Rebuild the code index.
+
+    ``--max-files`` defaults to None so an unset flag falls through to
+    ``CodeIndex.build_index``, which reads ``index_max_files`` from
+    ``.c3/config.json`` (2000 by default). Passing a hard-coded number here
+    would shadow that config for every caller who did not type the flag.
+
+    A truncated index is reported, never silent: the caller who sees only
+    "Files Indexed: 500" has no way to know 1400 files were skipped, and a
+    partial index answers searches with confident absences.
+    """
     config = deps.load_config()
     project_path = config.get("project_path", ".")
 
     deps.print_header("Rebuilding Code Index")
     indexer = deps.CodeIndex(project_path)
-    result = indexer.build_index(max_files=args.max_files or 500)
+    result = indexer.build_index(max_files=args.max_files)
+
+    capped = result.get("files_capped", 0) or 0
+    candidates = result["files_indexed"] + capped
 
     if deps.HAS_RICH:
         table = deps.Table(title="Index Results")
         table.add_column("Metric", style="cyan")
         table.add_column("Value", style="green")
-        table.add_row("Files Indexed", str(result["files_indexed"]))
+        files_cell = str(result["files_indexed"])
+        if capped:
+            files_cell = f"{result['files_indexed']} of {candidates}"
+        table.add_row("Files Indexed", files_cell)
         table.add_row("Chunks Created", str(result["chunks_created"]))
         table.add_row("Unique Symbols", str(result["unique_symbols"]))
+        if capped:
+            table.add_row("Files Skipped (cap)", str(capped))
         deps.console.print(table)
     else:
         print(f"  Files: {result['files_indexed']}, Chunks: {result['chunks_created']}, Symbols: {result['unique_symbols']}")
 
+    if capped:
+        print(f"  [!] Indexed {result['files_indexed']} of {candidates} candidate files "
+              f"(cap: index_max_files={result.get('max_files')}). {capped} skipped.")
+        print("      Raise index_max_files in .c3/config.json for full coverage.")
+
 
 def cmd_compress(args, deps: CommandDeps):
     """Compress a file and show results."""

{code_context_control-2.102.0 → code_context_control-2.110.0}/cli/commands/parser.py

@@ -34,7 +34,30 @@ def build_parser(version: str, parse_cli_ide_arg):
                            help="Only report whether a newer version exists; don't install")
 
     p_index = subparsers.add_parser("index", help="Rebuild code index")
-    p_index.add_argument("--max-files", type=int, default=500)
+    p_index.add_argument("--max-files", type=int, default=None,
+                         help="Cap files indexed this run. Unset reads "
+                              "index_max_files from .c3/config.json (2000).")
+
+    p_search_eval = subparsers.add_parser(
+        "search-eval", help="Run the c3_search relevance suite (docs/search-eval.md)")
+    p_search_eval.add_argument("--suite", default="fixture",
+                               help="'fixture' (synthetic repo, CI gate), 'golden' (this repo), or a .jsonl path")
+    p_search_eval.add_argument("--repo", default=None,
+                               help="Project to evaluate; overrides the suite header (real repos only)")
+    p_search_eval.add_argument("--semantic", choices=["off", "auto", "on"], default="auto",
+                               help="off: skip semantic cases; auto: run when embeddings are ready; "
+                                    "on: build embeddings first (needs Ollama)")
+    p_search_eval.add_argument("--rerank", choices=["off", "on"], default="off",
+                               help="on: attach the FlashRank reranker (needs the `rerank` extra) to measure it "
+                                    "against the same suite; off: the project's own config decides")
+    p_search_eval.add_argument("--rebuild", action="store_true",
+                               help="Rebuild the code index before running (real repos; fixtures always rebuild)")
+    p_search_eval.add_argument("--baseline", default=None, help="Baseline JSON to compare against / write")
+    p_search_eval.add_argument("--update-baseline", action="store_true",
+                               help="Write aggregates + per-query status to the baseline (floors are kept)")
+    p_search_eval.add_argument("--floors", default=None,
+                               help='With --update-baseline: JSON object of metric floors, e.g. \'{"mrr": 0.85}\'')
+    p_search_eval.add_argument("--json", action="store_true", help="Emit the full report as JSON")
 
     p_compress = subparsers.add_parser("compress", help="Compress a file")
     p_compress.add_argument("file", help="File to compress")

{code_context_control-2.102.0 → code_context_control-2.110.0}/cli/mcp_server.py

@@ -121,7 +121,10 @@ async def lifespan(server):
             transcript_index._load_index()
             transcript_index._load_manifest()
 
-    if not (Path(project) / ".c3" / "index" / "index.json").exists():
+    # No store yet, or only a pre-2.107.0 layout (index.json / lexical.sqlite)
+    # that a load would rebuild: either way the ~10 s build must stay off the
+    # MCP handshake path.
+    if (not services.indexer.index_exists()) or services.indexer.needs_migration():
         import threading
 
         def _bg_build():
@@ -479,9 +482,23 @@ def _finalize_response(ctx: Context, tool_name: str, args: dict,
 @mcp.tool()
 async def c3_search(query: str, action: str = "code", top_k: int = 3,
               max_tokens: int = 1200, prefetch: bool = False,
-              scope: str = "", ctx: Context = None) -> str:
+              scope: str = "", ignore_case: bool = False,
+              path: str = "", lang: str = "", kind: str = "",
+              ctx: Context = None) -> str:
     """FIND candidates. Use to discover which files/symbols are relevant (read-only, plan-mode safe).
-    action: 'code' (TF-IDF content), 'exact' (regex), 'files' (by name), 'transcript', 'semantic'.
+    action: 'code' (default: BM25 over identifiers and their parts, digits kept, fused with the embedding
+    index by reciprocal rank when one is ready; a query that IS a symbol name puts its definition first;
+    an oversized chunk comes back as a window), 'lexical' (the BM25 ranking alone), 'exact' (regex over
+    every indexed file, definitions printed first; ignore_case=True for case-insensitive), 'files' (by
+    filename: exact name, glob like 'configs/*.yml', or substring), 'semantic' (embeddings alone; falls
+    back to code search when empty), 'transcript'.
+    Filters (all actions but transcript, comma-separated): path='src/**,*.go' (globs or substrings),
+    lang='python,go' (names or extensions), kind='test,doc,config,source' and/or chunk types
+    'function,class,method,heading'. A query that names tests or asks a how-to question already
+    leans that way; filters make it exact.
+    top_k: up to 50 for 'files' and 'exact', 10 otherwise. Each hit header ends in the backend that
+    produced it ([lexical], [dense], [lexical+dense], symbol+, reranked); a zero result says which
+    action to try next.
     scope: '' current project | 'all' also searches linked sub-projects | '<name>' one sub-project.
     prefetch: auto-compress top results. Next step: c3_compress/c3_read on hits."""
     svc = _svc(ctx)
@@ -491,7 +508,8 @@ async def c3_search(query: str, action: str = "code", top_k: int = 3,
 
     return await asyncio.to_thread(handle_search, query, action, top_k, max_tokens, svc,
                                    finalize, maybe_related_facts, prefetch=prefetch,
-                                   scope=scope)
+                                   scope=scope, ignore_case=ignore_case,
+                                   path=path, lang=lang, kind=kind)
 
 
 @mcp.tool()

{code_context_control-2.102.0 → code_context_control-2.110.0}/cli/tools/federate.py

@@ -63,7 +63,9 @@ def subproject_scopes(svc, scope: str = "all") -> list:
 
 
 def federated_search(query: str, action: str, top_k: int, max_tokens: int,
-                     svc, finalize, maybe_facts, scope: str) -> str:
+                     svc, finalize, maybe_facts, scope: str,
+                     ignore_case: bool = False, path: str = "", lang: str = "",
+                     kind: str = "") -> str:
     """Sectioned fan-out search: parent (scope='all') + linked children.
 
     A child failure renders as a one-line error inside its section — it never
@@ -73,11 +75,12 @@ def federated_search(query: str, action: str, top_k: int, max_tokens: int,
 
     targets = subproject_scopes(svc, scope)
     parts = []
+    extra = {"ignore_case": ignore_case, "path": path, "lang": lang, "kind": kind}
 
     if scope == "all":
         parent_budget = max(200, int(max_tokens * _PARENT_BUDGET_SHARE)) if targets else max_tokens
         parts.append(handle_search(query, action, top_k, parent_budget, svc,
-                                   _noop_finalize, maybe_facts))
+                                   _noop_finalize, maybe_facts, **extra))
 
     if not targets:
         if scope != "all":
@@ -92,7 +95,7 @@ def federated_search(query: str, action: str, top_k: int, max_tokens: int,
             try:
                 fsvc = _child_runtime(t["path"])
                 body = handle_search(query, action, child_k, child_budget, fsvc,
-                                     _noop_finalize, _noop_facts)
+                                     _noop_finalize, _noop_facts, **extra)
             except Exception as e:
                 body = f"[error] {type(e).__name__}: {e}"
             parts.append(f"=== [sub:{t['name']}] ===\n{body}")