code-context-control 2.110.1__tar.gz → 2.112.0__tar.gz

{code_context_control-2.110.1 → code_context_control-2.112.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.110.1
+Version: 2.112.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.110.1 → code_context_control-2.112.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.110.1"
+__version__ = "2.112.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -1536,6 +1536,40 @@ def cmd_search_eval(args):
         sys.exit(1)
 
 
+def cmd_shell_eval(args):
+    """Run the c3_shell output-shaping suite and compare it to its baseline.
+
+    Exit status 1 when the baseline is violated (a must_pass case failed, an
+    aggregate fell under its floor or rose over its ceiling). See
+    docs/shell-eval.md.
+    """
+    from services.bench import shell_eval as she
+
+    try:
+        report = she.run_suite(args.suite, baseline=args.baseline)
+    except FileNotFoundError as e:
+        raise RuntimeError(str(e))
+
+    if args.update_baseline:
+        path = args.baseline or she.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
+        ceilings = json.loads(args.ceilings) if args.ceilings else None
+        she.write_baseline(report, path, floors=floors, ceilings=ceilings)
+        report.baseline_violations, report.baseline_warnings = she.compare_to_baseline(
+            report, she.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
@@ -9200,6 +9234,7 @@ def main():
         "map": cmd_map,
         "stats": cmd_stats,
         "search-eval": cmd_search_eval,
+        "shell-eval": cmd_shell_eval,
         "benchmark": cmd_benchmark,
         "session-benchmark": cmd_session_benchmark,
         "benchmark-e2e": cmd_benchmark_e2e,

{code_context_control-2.110.1 → code_context_control-2.112.0}/cli/commands/parser.py

@@ -59,6 +59,19 @@ def build_parser(version: str, parse_cli_ide_arg):
                                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_shell_eval = subparsers.add_parser(
+        "shell-eval", help="Run the c3_shell output-shaping suite (docs/shell-eval.md)")
+    p_shell_eval.add_argument("--suite", default="fixture",
+                              help="'fixture' (synthetic outputs, CI gate) or a .jsonl path")
+    p_shell_eval.add_argument("--baseline", default=None, help="Baseline JSON to compare against / write")
+    p_shell_eval.add_argument("--update-baseline", action="store_true",
+                              help="Write aggregates + per-case status to the baseline (floors/ceilings are kept)")
+    p_shell_eval.add_argument("--floors", default=None,
+                              help='With --update-baseline: JSON object of metric floors, e.g. \'{"must_keep_retention": 0.9}\'')
+    p_shell_eval.add_argument("--ceilings", default=None,
+                              help='With --update-baseline: JSON object of metric ceilings, e.g. \'{"bytes_p95": 18432}\'')
+    p_shell_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")
     p_compress.add_argument("--mode", choices=["map", "dense_map", "smart", "diff"], default="smart")

{code_context_control-2.110.1 → code_context_control-2.112.0}/cli/mcp_server.py

@@ -883,16 +883,28 @@ async def c3_impact(target: str, file_path: str = "", mode: str = "symbol",
 
 
 @mcp.tool()
-async def c3_shell(cmd: str, cwd: str = "", timeout: int = 60,
+async def c3_shell(cmd: str = "", cwd: str = "", timeout: int = 60,
                    filter_output: bool = True, log: bool = True,
                    env_creds: str = "",
+                   output_id: str = "", output_action: str = "",
+                   pattern: str = "", lines: str = "", stream: str = "stdout",
+                   max_bytes: int = 0,
                    ctx: Context = None) -> str:
-    """EXECUTE shell command — structured returns, auto-filter, ledger-aware.
+    """EXECUTE shell command — structured returns, budgeted output, ledger-aware.
     Use for tests, git, build, scripts. Returns exit_code/stdout/stderr/duration_ms.
-    Auto-filters stdout >30 lines; auto-logs git mutations to the edit ledger.
+    The response never exceeds 18 KiB (max_bytes may only lower it): a stream that does
+    not fit is clipped line by line and windowed head/tail with a note naming an
+    output_id; the raw streams are kept for 3 days OUTSIDE the project. Page them back
+    with output_id='o-…' and output_action='read' (lines='120-180'), 'search'
+    (pattern=regex), 'tail' (lines='80') or 'delete', stream='stdout'|'stderr'; an id
+    resolves only for this project and this session under the current access rules.
+    The echoed command is its first line; a multi-line command shows (N lines, M chars,
+    sha256). Auto-filters stdout >30 lines when it fits; auto-logs git mutations to
+    the edit ledger.
     Credentials: env_creds='NAME1,NAME2' injects vault entries as env vars, and
     {{cred:NAME}} inside cmd expands server-side — decoded values never enter
-    model context (see c3_credentials; echoed values are auto-redacted).
+    model context (see c3_credentials; echoed values are auto-redacted, in the
+    response and in the kept output).
     Best-effort block of catastrophic commands (rm -rf of /, a top-level system dir, or
     $HOME/~; fork bombs; whole-drive wipes) — a guard, NOT a sandbox. Soft-warns on
     --force, --no-verify, reset --hard.
@@ -904,7 +916,10 @@ async def c3_shell(cmd: str, cwd: str = "", timeout: int = 60,
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
     return await handle_shell(cmd, cwd, timeout, filter_output, log, svc, finalize,
-                              env_creds=env_creds)
+                              env_creds=env_creds, output_id=output_id,
+                              output_action=output_action, pattern=pattern,
+                              lines=lines or None, stream=stream or "stdout",
+                              max_bytes=max_bytes or None)
 
 
 @mcp.tool()

{code_context_control-2.110.1 → code_context_control-2.112.0}/cli/tools/_helpers.py

@@ -81,7 +81,7 @@ def show_token_ratios(svc) -> bool:
 def finalize_with_tokens(finalize, svc, tool_name: str, args: dict,
                          response: str, summary: str = "", *,
                          raw_tokens=None, optimized_tokens=None,
-                         duration_ms=None, **finalize_kwargs) -> str:
+                         duration_ms=None, detail=None, **finalize_kwargs) -> str:
     """Finalize a tool response with STRUCTURED token accounting.
 
     This is the primary accounting path: tools pass explicitly measured
@@ -100,6 +100,10 @@ def finalize_with_tokens(finalize, svc, tool_name: str, args: dict,
     ``estimated_saved_vs_full_read`` in session token_usage and in the
     per-tool telemetry JSONL (.c3/tool_telemetry.jsonl).
 
+    ``detail`` is an optional flat dict of tool-specific facts about this
+    call; it lands under the telemetry record's ``detail`` key (see
+    SessionManager.record_tool_tokens).
+
     Failure-safe: accounting errors never break the tool response. Any extra
     keyword args (e.g. response_tokens) are forwarded to ``finalize``.
     """
@@ -107,10 +111,11 @@ def finalize_with_tokens(finalize, svc, tool_name: str, args: dict,
         session_mgr = getattr(svc, "session_mgr", None)
         if session_mgr is not None and (
                 raw_tokens is not None or optimized_tokens is not None
-                or duration_ms is not None):
+                or duration_ms is not None or detail):
             session_mgr.record_tool_tokens(
                 tool_name, raw_tokens=raw_tokens,
-                optimized_tokens=optimized_tokens, duration_ms=duration_ms)
+                optimized_tokens=optimized_tokens, duration_ms=duration_ms,
+                detail=detail)
     except Exception:
         pass
     return finalize(tool_name, args, response, summary, **finalize_kwargs)