code-context-control 2.82.0__tar.gz → 2.85.0__tar.gz

{code_context_control-2.82.0/code_context_control.egg-info → code_context_control-2.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.82.0
+Version: 2.85.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.82.0 → code_context_control-2.85.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.82.0"
+__version__ = "2.85.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -6055,6 +6055,15 @@ def _ci_main(args) -> int:
     from cli.tools.ci import handle_ci
 
     sub = getattr(args, "ci_cmd", None) or "inspect"
+    if sub == "publish":
+        if getattr(args, "dry_run", False):
+            args.job = "dry-run"
+        if getattr(args, "force", False):
+            args.allow_side_effects = True
+    if sub == "cache" and getattr(args, "clear", False):
+        # `--clear` is a flag on the CLI; the shared handler takes it
+        # positionally so both surfaces route through one code path.
+        args.job = "clear"
     project_path = getattr(args, "project_path", ".") or "."
     as_json = bool(getattr(args, "json", False))
 
@@ -6106,7 +6115,11 @@ def _ci_main(args) -> int:
         getattr(args, "event", "") or "",
         getattr(args, "engine", "auto") or "auto",
         bool(getattr(args, "allow_side_effects", False)),
-        getattr(args, "network", "") or "")
+        getattr(args, "network", "") or "",
+        "required" if getattr(args, "required", False) else "full",
+        getattr(args, "base", "") or "",
+        bool(getattr(args, "allow_host_mutation", False)),
+        bool(getattr(args, "no_cache", False)))
     print(out)
     # Exit code is the finding: a non-full verdict must not read as success to
     # a shell script or a pre-push hook.

{code_context_control-2.82.0 → code_context_control-2.85.0}/cli/commands/parser.py

@@ -507,6 +507,17 @@ def build_parser(version: str, parse_cli_ide_arg):
     ci_run.add_argument("--allow-side-effects", action="store_true",
                         help="Let the act engine run jobs that look like they "
                              "publish or deploy. Refused by default.")
+    ci_run.add_argument("--required", action="store_true",
+                        help="Run only the jobs a change could have broken "
+                             "(conservative; see `c3 ci plan`)")
+    ci_run.add_argument("--base", default="",
+                        help="Diff against this ref instead of the working tree")
+    ci_run.add_argument("--allow-host-mutation", action="store_true",
+                        help="Permit native steps that reconfigure this machine "
+                             "(pip/npm -g/apt install). Refused by default.")
+    ci_run.add_argument("--no-cache", action="store_true",
+                        help="Ignore cached results and execute every "
+                             "selected job")
     ci_run.add_argument("--network", default="",
                         help="Container network for the act engine (e.g. `none` "
                              "to cut egress). Default: act's own.")
@@ -530,6 +541,22 @@ def build_parser(version: str, parse_cli_ide_arg):
     ci_logs.add_argument("--tail", type=int, default=200)
 
     _ci_common(ci_subs.add_parser("runs", help="Recent local CI runs"))
+    ci_plan = _ci_common(ci_subs.add_parser(
+        "plan", help="Show which jobs a change requires, and why"))
+    ci_plan.add_argument("--base", default="",
+                         help="Diff against this ref instead of the working tree")
+    ci_pub = _ci_common(ci_subs.add_parser(
+        "publish", help="Post the last run as a GitHub commit status"))
+    ci_pub.add_argument("--run", dest="run_id", default="")
+    ci_pub.add_argument("--dry-run", action="store_true")
+    ci_pub.add_argument("--force", action="store_true",
+                        help="Publish a PARTIAL result as `pending`")
+    _ci_common(ci_subs.add_parser(
+        "history", help="Per-job pass/fail history and flake detection"))
+    ci_cache_p = _ci_common(ci_subs.add_parser(
+        "cache", help="Cached-result store: size, or --clear it"))
+    ci_cache_p.add_argument("--clear", action="store_true",
+                            help="Drop every cached result and dependency cache")
     _ci_common(ci_subs.add_parser(
         "doctor", help="Which execution engines are available on this machine"))
 

{code_context_control-2.82.0 → code_context_control-2.85.0}/cli/mcp_server.py

@@ -771,10 +771,25 @@ async def c3_ci(action: str = "inspect", job: str = "", run_id: str = "",
                 allow_foreign: bool = False, workflow: str = "",
                 tail: int = 200, timeout: int = 0, event: str = "",
                 engine: str = "auto", allow_side_effects: bool = False,
-                network: str = "", ctx: Context = None) -> str:
+                network: str = "", mode: str = "full", base: str = "",
+                allow_host_mutation: bool = False,
+                no_cache: bool = False, ctx: Context = None) -> str:
     """RUN THIS REPO'S REAL CI LOCALLY — before pushing, not after.
     Reads .github/workflows/*.yml as the source of truth (no second CI config).
-    actions: inspect | run | rerun | status | failures | logs | runs | doctor.
+    actions: inspect | plan | run | rerun | status | failures | logs | runs |
+      cache | history | publish | doctor. publish posts the last run as a
+      GitHub COMMIT STATUS via your gh auth; it refuses a dirty tree, an
+      unpushed commit, and (unless forced) a PARTIAL result. history reports per-job fail rates and
+      flags FLAKY jobs — ones that both passed and failed on identical
+      inputs, so the code cannot be the cause. A job whose inputs are unchanged since it last passed
+      is reused (status `cached`, nothing executed); no_cache forces it.
+    mode: full (default) | required. required runs only the jobs a change
+      could have broken; it is CONSERVATIVE — anything unmapped runs. Use
+      action='plan' to see the decision and reason for every job first.
+    allow_host_mutation: the NATIVE engine refuses steps that would
+      reconfigure this machine (pip/npm -g/apt/brew install...). It has no
+      isolation; running this repo's own CI natively once uninstalled C3.
+      Prefer engine='act'.
     inspect: workflows, the job DAG, and which jobs are runnable on THIS host.
     run: execute in dependency order; job='lint' or 'test (ubuntu-latest, 3.12)'
       selects one (bare job name = all its matrix cells). A job whose dependency
@@ -798,7 +813,9 @@ async def c3_ci(action: str = "inspect", job: str = "", run_id: str = "",
     return await asyncio.to_thread(handle_ci, action, job, run_id,
                                    allow_foreign, workflow, tail, timeout,
                                    svc, finalize, event, engine,
-                                   allow_side_effects, network)
+                                   allow_side_effects, network,
+                                   mode, base, allow_host_mutation,
+                                   no_cache)
 
 
 @mcp.tool()

{code_context_control-2.82.0 → code_context_control-2.85.0}/cli/tools/ci.py

@@ -12,13 +12,14 @@ That distinction is the product.
 """
 from __future__ import annotations
 
+from services import ci_impact
 from services import ci_runner as cr
 from services.ci_workflow import inspect_project
 
 _MARK = {
     cr.PASSED: "PASS", cr.FAILED: "FAIL", cr.SKIPPED: "SKIP",
     cr.UNSUPPORTED: "UNSUP", cr.FOREIGN: "OTHER-OS", cr.TIMEOUT: "TIMEOUT",
-    cr.DESELECTED: "-",
+    cr.DESELECTED: "-", cr.CACHED: "CACHED",
 }
 
 # Verdicts an agent may treat as "safe to push". Deliberately one item long.
@@ -81,7 +82,10 @@ def _failure_rows(jobs: list, limit: int = 25) -> list:
 def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
               workflow: str, tail: int, timeout: int, svc, finalize,
               event: str = "", engine: str = "auto",
-              allow_side_effects: bool = False, network: str = "") -> str:
+              allow_side_effects: bool = False, network: str = "",
+              mode: str = "full", base: str = "",
+              allow_host_mutation: bool = False,
+              no_cache: bool = False) -> str:
     """Route c3_ci actions."""
     project = str(svc.project_path)
     action = (action or "inspect").strip().lower()
@@ -152,6 +156,43 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
         return finalize("c3_ci", args, "\n".join(lines),
                         f"{len(data['jobs'])} jobs, {len(data['runnable'])} runnable")
 
+    # ── plan (required mode, no execution) ───────────────────────────────
+    if action == "plan":
+        from services.ci_workflow import (
+            build_dag,
+            discover_workflows,
+            git_context,
+            parse_workflow,
+        )
+        wfs = [parse_workflow(p) for p in discover_workflows(project)]
+        dag = build_dag([w for w in wfs if not w.error],
+                        event=event, git=git_context(project))
+        try:
+            ordered = dag.topo_order()
+        except Exception:
+            ordered = dag.instances
+        plan = ci_impact.plan_required(project, ordered, wfs, base=base,
+                                       event=event)
+        lines = [
+            f"Required-mode plan ({len(plan.selected)} run / "
+            f"{len(plan.skipped)} skip) vs {base or 'the working tree'}",
+            f"changed files: {len(plan.changed)}",
+        ]
+        for path in plan.changed[:10]:
+            lines.append(f"  {path}")
+        if len(plan.changed) > 10:
+            lines.append(f"  ... and {len(plan.changed) - 10} more")
+        lines.append("")
+        for decision in plan.decisions:
+            mark = "RUN " if decision.decision == ci_impact.RUN else "skip"
+            lines.append(f"  {mark} {decision.job}")
+            lines.append(f"       {decision.reason}")
+        if plan.note:
+            lines.append(f"\n{plan.note}")
+        lines.append("\nRun it: c3_ci(action='run', mode='required')")
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{len(plan.selected)} required")
+
     # ── run / rerun ──────────────────────────────────────────────────────
     if action in ("run", "rerun"):
         only = None
@@ -172,7 +213,9 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
                            only=only, timeout=timeout or cr.DEFAULT_STEP_TIMEOUT,
                            workflow=workflow, event=event, engine=engine,
                            allow_side_effects=allow_side_effects,
-                           network=network)
+                           network=network, mode=mode, base=base,
+                           allow_host_mutation=allow_host_mutation,
+                           no_cache=no_cache)
         run = result.to_dict()
         lines = [_verdict_line(run), f"run {run['run_id']}  host={run['host_os']}"]
         fp = run.get("fingerprint") or {}
@@ -245,6 +288,86 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
                          f"{row.get('started_at', '')[:19]}  {tally}")
         return finalize("c3_ci", args, "\n".join(lines), f"{len(rows)} runs")
 
+    # ── history / intelligence ───────────────────────────────────────────
+    if action in ("history", "intel", "flaky"):
+        from services import ci_intel
+        data = ci_intel.analyse(project)
+        if not data["runs_analysed"]:
+            return finalize("c3_ci", args, data["note"], "no history")
+        lines = [data["note"], ""]
+        if data["flaky"]:
+            lines.append("FLAKY — passed AND failed on identical inputs:")
+            for job in data["flaky"]:
+                lines.append(f"  {job['key']}  {job['failed']}/{job['executed']} failed")
+                lines.append("      same fingerprint gave both answers, so the "
+                             "code did not change between them")
+            lines.append("")
+        lines.append(f"{'job':<40}{'exec':>5}{'fail':>6}{'rate':>7}{'avg':>8}")
+        for job in data["jobs"][:15]:
+            rate = f"{job['fail_rate']:.0%}" if job["executed"] else "-"
+            avg = f"{job['avg_ms'] / 1000:.1f}s" if job["avg_ms"] else "-"
+            mark = "" if job["confident"] else "  (low n)"
+            lines.append(f"  {job['key']:<38}{job['executed']:>5}"
+                         f"{job['failed']:>6}{rate:>7}{avg:>8}{mark}")
+        if data["slowest"]:
+            lines.append("\nSlowest: " + ", ".join(
+                f"{j['key']} {j['avg_ms'] / 1000:.1f}s" for j in data["slowest"][:3]))
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{len(data['flaky'])} flaky")
+
+    # ── publish (GitHub commit status) ───────────────────────────────────
+    if action == "publish":
+        from services import ci_github
+        run = cr.load_run(project, run_id)
+        if not run:
+            return finalize("c3_ci", args, "No run to publish.", "no runs")
+        res = ci_github.publish(project, run,
+                                force=allow_side_effects,
+                                dry_run=(job or "").lower() == "dry-run")
+        if res.get("dry_run"):
+            body = "\n".join([
+                f"Would POST {res['endpoint']}",
+                f"  state={res['state']}",
+                f"  {res['description']}",
+            ])
+            return finalize("c3_ci", args, body, "dry run")
+        if not res.get("published"):
+            return finalize("c3_ci", args,
+                            f"Not published: {res.get('reason')}", "refused")
+        body = (f"Published {res['state']} to {res['sha'][:8]} "
+                f"as {res['context']}.\n  {res['description']}")
+        return finalize("c3_ci", args, body, res["state"])
+
+    # ── cache ────────────────────────────────────────────────────────────
+    if action == "cache":
+        from services import ci_cache
+        if (job or "").strip().lower() == "clear" or run_id == "clear":
+            freed = ci_cache.clear(project)
+            return finalize("c3_ci", args,
+                            f"Cleared the CI cache ({freed / 1024:.0f} KB).",
+                            "cache cleared")
+        info = ci_cache.stats(project)
+        rules = ci_impact.load_rules(project)
+        lines = [
+            f"Cached results: {info['results']}",
+            f"Dependency cache keys: {info['dependency_keys']}",
+            f"Location: {info['dir']}",
+            "",
+            "A job is reused when its definition, engine and inputs are all "
+            "unchanged since it last passed.",
+        ]
+        if rules:
+            lines.append(
+                f"{len(rules)} job(s) declare inputs via ci.required_map, so "
+                "only those paths invalidate them.")
+        else:
+            lines.append(
+                "No ci.required_map: every job is fingerprinted over the whole "
+                "tree, so any edit invalidates every cached result. Declaring "
+                "inputs is what makes the cache bite.")
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{info['results']} cached")
+
     # ── doctor ───────────────────────────────────────────────────────────
     if action == "doctor":
         from services import ci_act

{code_context_control-2.82.0 → code_context_control-2.85.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.82.0
+Version: 2.85.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.82.0 → code_context_control-2.85.0}/code_context_control.egg-info/SOURCES.txt

@@ -186,8 +186,12 @@ services/benchmark_dashboard.py
 services/bitbucket_client.py
 services/bitbucket_credentials.py
 services/ci_act.py
+services/ci_cache.py
 services/ci_expr.py
 services/ci_failures.py
+services/ci_github.py
+services/ci_impact.py
+services/ci_intel.py
 services/ci_runner.py
 services/ci_workflow.py
 services/circuit_breaker.py
@@ -283,7 +287,10 @@ tests/test_c3_bridge_project_artifacts.py
 tests/test_c3_shell.py
 tests/test_chat_poll.py
 tests/test_ci_act.py
+tests/test_ci_cache.py
 tests/test_ci_expr.py
+tests/test_ci_impact.py
+tests/test_ci_intel.py
 tests/test_ci_runner.py
 tests/test_ci_workflow.py
 tests/test_circuit_breaker.py

{code_context_control-2.82.0 → code_context_control-2.85.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.82.0"
+version = "2.85.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.82.0 → code_context_control-2.85.0}/services/ci_act.py

@@ -154,6 +154,42 @@ def side_effects(inst) -> list:
     return found
 
 
+# ── Host-mutation gate (native engine only) ─────────────────────────────────
+# Learned the hard way, on this repository. A required-mode run selected every
+# job and the native engine executed C3's own `test` job, whose steps are
+# `python -m pip install -e ".[dev]"`. That uninstalled the copied C3 from
+# site-packages and replaced it with an editable install pointing at the repo;
+# the run then timed out mid-write and left the package — and every project's
+# hooks — broken.
+#
+# The native engine has no isolation: a `run:` step executes as the user, on
+# the user's machine, against the user's interpreter. Most CI jobs begin by
+# installing dependencies, so "run the repo's real CI natively" means "let a
+# YAML file reconfigure this machine". Under act the same step is contained and
+# harmless, which is why the refusal points there rather than just saying no.
+_HOST_MUTATION = re.compile(
+    r"(?:^|[\s;&|])(?:"
+    r"pip\s+(?:install|uninstall)|pip3\s+(?:install|uninstall)"
+    r"|python\s+-m\s+pip\s+(?:install|uninstall)"
+    r"|npm\s+(?:i|install)\s+(?:-g|--global)|npm\s+uninstall\s+(?:-g|--global)"
+    r"|yarn\s+global\s+add|pnpm\s+add\s+(?:-g|--global)"
+    r"|apt(?:-get)?\s+(?:install|remove|purge)|yum\s+install|dnf\s+install"
+    r"|brew\s+(?:install|uninstall)|choco\s+install|winget\s+install"
+    r"|cargo\s+install|go\s+install|gem\s+install"
+    r"|rustup\s|nvm\s+install|conda\s+(?:install|remove)"
+    r")\b", re.IGNORECASE)
+
+
+def host_mutations(inst) -> list:
+    """Steps that would reconfigure THIS machine if run without a container."""
+    found: list = []
+    for step in getattr(inst, "steps", []):
+        match = _HOST_MUTATION.search(str(getattr(step, "run", "") or ""))
+        if match:
+            found.append(f"step {step.index} runs `{match.group(0).strip()}`")
+    return found
+
+
 # ── Command construction ────────────────────────────────────────────────────
 
 def build_command(inst, project, act_path: str, event: str = "",