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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.80.0
+Version: 2.82.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
@@ -202,7 +202,7 @@ C3 exposes **21 tools** as a native MCP server. Your IDE calls them directly:
 | `c3_session` | Snapshot, restore, log decisions, compact history |
 | `c3_impact` | Blast-radius analysis before editing shared symbols |
 | `c3_locks` | Agent leases — who is working on which file, so two agents don't collide (v2.65.0) |
-| `c3_ci` | Run this repo's real `.github/workflows` locally, with structured failures, before pushing (v2.79.0) |
+| `c3_ci` | Run this repo's real `.github/workflows` locally — in containers via `act` — with structured failures, before pushing (v2.79.0) |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini |
 | `c3_agent` | Workflows: `review_changes`, `investigate`, `preflight`, `prepare_context`, `validate_compress` |
 | `c3_edits` | Edit-ledger queries, version diffs, restore points, per-branch filter, `verify` (did a failed `c3_edit` still land?) |

{code_context_control-2.80.0 → code_context_control-2.82.0}/README.md

@@ -139,7 +139,7 @@ C3 exposes **21 tools** as a native MCP server. Your IDE calls them directly:
 | `c3_session` | Snapshot, restore, log decisions, compact history |
 | `c3_impact` | Blast-radius analysis before editing shared symbols |
 | `c3_locks` | Agent leases — who is working on which file, so two agents don't collide (v2.65.0) |
-| `c3_ci` | Run this repo's real `.github/workflows` locally, with structured failures, before pushing (v2.79.0) |
+| `c3_ci` | Run this repo's real `.github/workflows` locally — in containers via `act` — with structured failures, before pushing (v2.79.0) |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini |
 | `c3_agent` | Workflows: `review_changes`, `investigate`, `preflight`, `prepare_context`, `validate_compress` |
 | `c3_edits` | Edit-ledger queries, version diffs, restore points, per-branch filter, `verify` (did a failed `c3_edit` still land?) |

{code_context_control-2.80.0 → code_context_control-2.82.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.80.0"
+__version__ = "2.82.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -6065,7 +6065,9 @@ def _ci_main(args) -> int:
         from services import ci_runner as cr
         from services.ci_workflow import inspect_project
         if sub == "inspect":
-            payload = inspect_project(project_path, event=getattr(args, "event", "") or "")
+            payload = inspect_project(
+                project_path, event=getattr(args, "event", "") or "",
+                engine=getattr(args, "engine", "auto") or "auto")
         elif sub in ("run", "rerun"):
             only = None
             if sub == "rerun":
@@ -6079,7 +6081,10 @@ def _ci_main(args) -> int:
                 allow_foreign=bool(getattr(args, "allow_foreign", False)),
                 only=only, timeout=getattr(args, "timeout", 0) or cr.DEFAULT_STEP_TIMEOUT,
                 workflow=getattr(args, "workflow", ""),
-                event=getattr(args, "event", "") or "").to_dict()
+                event=getattr(args, "event", "") or "",
+                engine=getattr(args, "engine", "auto") or "auto",
+                allow_side_effects=bool(getattr(args, "allow_side_effects", False)),
+                network=getattr(args, "network", "") or "").to_dict()
         elif sub == "runs":
             payload = {"runs": cr.list_runs(project_path)}
         else:
@@ -6098,7 +6103,10 @@ def _ci_main(args) -> int:
         bool(getattr(args, "allow_foreign", False)),
         getattr(args, "workflow", "") or "", getattr(args, "tail", 200) or 200,
         getattr(args, "timeout", 0) or 0, svc, finalize,
-        getattr(args, "event", "") or "")
+        getattr(args, "event", "") or "",
+        getattr(args, "engine", "auto") or "auto",
+        bool(getattr(args, "allow_side_effects", False)),
+        getattr(args, "network", "") or "")
     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.80.0 → code_context_control-2.82.0}/cli/commands/parser.py

@@ -500,6 +500,16 @@ def build_parser(version: str, parse_cli_ide_arg):
                              "can never yield FULL_CI_PASS)")
     ci_run.add_argument("--timeout", type=int, default=0,
                         help="Per-step timeout in seconds (default 900)")
+    ci_run.add_argument("--engine", choices=["auto", "native", "act"],
+                        default="auto",
+                        help="auto (default) uses act for Linux jobs when act + "
+                             "Docker are present, native otherwise")
+    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("--network", default="",
+                        help="Container network for the act engine (e.g. `none` "
+                             "to cut egress). Default: act's own.")
 
     ci_rerun = _ci_common(ci_subs.add_parser(
         "rerun", help="Re-run only the jobs that failed in the last run"))
@@ -520,6 +530,8 @@ 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_common(ci_subs.add_parser(
+        "doctor", help="Which execution engines are available on this machine"))
 
     # ── Override Requests (v2.69.0, docs/override-requests.md) ──────────
     # Human-only approval surface. A grant is single-use, session-bound,

{code_context_control-2.80.0 → code_context_control-2.82.0}/cli/hub_server.py

@@ -1293,11 +1293,12 @@ _ci_runs: dict = {}          # project path -> in-flight state
 _ci_lock = threading.Lock()
 
 
-def _ci_worker(project: str, job: str, allow_foreign: bool, workflow: str) -> None:
+def _ci_worker(project: str, job: str, allow_foreign: bool, workflow: str,
+               engine: str = "auto") -> None:
     from services import ci_runner as cr
     try:
         result = cr.run_ci(project, selector=job, allow_foreign=allow_foreign,
-                           workflow=workflow)
+                           workflow=workflow, engine=engine)
         payload = {"running": False, "done": True, "error": None,
                    "run_id": result.run_id, "verdict": result.verdict,
                    "note": result.note}
@@ -1320,6 +1321,8 @@ def api_ci_inspect():
     except ValueError as e:
         return jsonify({"error": str(e)}), 404
     try:
+        # inspect_project owns the engine partition, so the Hub, the CLI
+        # and the tool text can never disagree about what is runnable.
         return jsonify(inspect_project(resolved))
     except Exception as e:
         return jsonify({"error": f"{type(e).__name__}: {e}"}), 500
@@ -1391,7 +1394,8 @@ def api_ci_run_start():
     threading.Thread(
         target=_ci_worker,
         args=(resolved, str(data.get("job") or ""),
-              bool(data.get("allow_foreign")), str(data.get("workflow") or "")),
+              bool(data.get("allow_foreign")), str(data.get("workflow") or ""),
+              str(data.get("engine") or "auto")),
         daemon=True,
     ).start()
     return jsonify({"started": True})

{code_context_control-2.80.0 → code_context_control-2.82.0}/cli/hub_ui/components/hub_ci.js

@@ -18,6 +18,11 @@ const CI_STATUS_STYLE = {
   unsupported: ['UNSUP', 'warn'],
   foreign: ['OTHER-OS', 'blue'],
   deselected: ['—', 'textDim'],
+  // capability labels, used by the job graph only
+  cap_native: ['NATIVE', 'accent'],
+  cap_container: ['CONTAINER', 'accent'],
+  cap_unreachable: ['OTHER-OS', 'blue'],
+  cap_unsupported: ['UNSUP', 'warn'],
 };
 
 function CiStatusPill({ status, title }) {
@@ -142,6 +147,10 @@ function HubCI({ projects, onOpenDrill }) {
   };
 
   const jobs = (inspect && inspect.jobs) || [];
+  const engines = inspect && inspect.engines;
+  const runnableNative = new Set((inspect && inspect.runnable_native) || []);
+  const runnableContainer = new Set((inspect && inspect.runnable_container) || []);
+  const unsupportedKeys = new Set(((inspect && inspect.unsupported) || []).map(u => u.key));
   const runJobs = ((run && run.jobs) || []).filter(j => j.status !== 'deselected');
 
   return (
@@ -151,7 +160,8 @@ function HubCI({ projects, onOpenDrill }) {
         <span style={{ fontSize: 14, color: T.text }}>Local CI</span>
         <span className="mono" style={{ fontSize: 11, color: T.textMuted }}>
           {inspect
-            ? `${(inspect.runnable || []).length} of ${jobs.length} job(s) runnable on ${inspect.host_os}`
+            ? `${(inspect.runnable || []).length} of ${jobs.length} runnable here`
+              + ` (${runnableNative.size} native, ${runnableContainer.size} container)`
             : 'loading…'}
         </span>
         <div style={{ flex: 1 }} />
@@ -172,8 +182,16 @@ function HubCI({ projects, onOpenDrill }) {
         border: `1px solid ${T.border}`, borderRadius: 6, padding: '8px 10px', lineHeight: 1.5,
       }}>
         Runs the repository's real <span className="mono">.github/workflows</span> here —
-        C3 does not define a second CI config. Jobs targeting another OS are refused
-        unless you opt in, and a cross-OS result is indicative, never equivalent.
+        C3 does not define a second CI config.{' '}
+        {engines && engines.ok ? (
+          <span>Linux jobs run in a container via <span className="mono">act</span>{' '}
+            ({engines.act_version}, docker {engines.docker_version}), real actions included.</span>
+        ) : (
+          <span style={{ color: T.warn }}>
+            Container engine unavailable — {(engines && engines.reason) || 'checking…'}
+          </span>
+        )}{' '}
+        macOS jobs can never run locally: there are no macOS containers.
       </div>
 
       {err && (
@@ -236,8 +254,12 @@ function HubCI({ projects, onOpenDrill }) {
                 <span className="mono" style={{
                   color: T.text, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
                 }}>{j.key}</span>
-                {j.cross_os && j.status === 'passed' && (
-                  <span className="mono" title={`Ran on this host, but targets ${j.runs_on}.`}
+                {j.status === 'passed' && j.fidelity === 'container' && (
+                  <span className="mono" title={`Ran in a container of ${j.runs_on} via act — real actions included.`}
+                    style={{ fontSize: 10, color: T.accent }}>container</span>
+                )}
+                {j.status === 'passed' && j.fidelity === 'cross-os' && (
+                  <span className="mono" title={`Ran on this host, but targets ${j.runs_on}. Indicative, not equivalent.`}
                     style={{ fontSize: 10, color: T.blue }}>cross-OS</span>
                 )}
                 <div style={{ flex: 1 }} />
@@ -276,10 +298,22 @@ function HubCI({ projects, onOpenDrill }) {
               display: 'flex', alignItems: 'center', gap: 9, padding: '5px 10px',
               borderTop: `1px solid ${T.border}`, fontSize: 11,
             }}>
+              {/* Read the server's partition; never re-derive it here. The
+                  first attempt inferred runnability in JS from act_could_run,
+                  which means "act has no blockers with this job" and NOT "act
+                  can run it here" — act only does Linux. Every macOS cell
+                  rendered as a green PASS it could never earn. */}
               <CiStatusPill
-                status={!j.supported ? 'unsupported' : (j.foreign_runner ? 'foreign' : 'passed')}
-                title={!j.supported ? (j.blockers || []).join('; ')
-                  : (j.foreign_runner ? `targets ${j.runs_on}` : 'runnable on this host')} />
+                status={runnableNative.has(j.key) ? 'cap_native'
+                  : runnableContainer.has(j.key) ? 'cap_container'
+                    : unsupportedKeys.has(j.key) ? 'cap_unsupported'
+                      : 'cap_unreachable'}
+                title={runnableNative.has(j.key) ? 'runnable natively on this host'
+                  : runnableContainer.has(j.key)
+                    ? `runs in a container (${j.runs_on}) via act`
+                    : unsupportedKeys.has(j.key)
+                      ? (j.blockers || []).join('; ')
+                      : `targets ${j.runs_on} — no available engine can run it here`} />
               <span className="mono" style={{ color: T.textMuted }}>{j.key}</span>
               {!!(j.needs || []).length && (
                 <span className="mono" style={{ fontSize: 10, color: T.textDim }}>

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

@@ -770,10 +770,11 @@ async def c3_locks(action: str = "list", paths: str = "", intent: str = "",
 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 = "",
-                ctx: Context = None) -> str:
+                engine: str = "auto", allow_side_effects: bool = False,
+                network: str = "", 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 (default) | run | rerun | status | failures | logs | runs.
+    actions: inspect | run | rerun | status | failures | logs | runs | doctor.
     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
@@ -796,7 +797,8 @@ async def c3_ci(action: str = "inspect", job: str = "", run_id: str = "",
     from cli.tools.ci import handle_ci
     return await asyncio.to_thread(handle_ci, action, job, run_id,
                                    allow_foreign, workflow, tail, timeout,
-                                   svc, finalize, event)
+                                   svc, finalize, event, engine,
+                                   allow_side_effects, network)
 
 
 @mcp.tool()

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

@@ -39,7 +39,12 @@ def _job_rows(jobs: list, include_deselected: bool = False) -> list:
         if status == cr.DESELECTED and not include_deselected:
             continue
         mark = _MARK.get(status, status.upper())
-        cross = " [cross-OS]" if job.get("cross_os") and status == cr.PASSED else ""
+        fid = job.get("fidelity", "")
+        cross = ""
+        if status == cr.PASSED and fid == cr.FIDELITY_CONTAINER:
+            cross = " [container]"
+        elif status == cr.PASSED and fid == cr.FIDELITY_CROSS_OS:
+            cross = " [cross-OS]"
         ms = job.get("duration_ms") or 0
         timing = f"  {ms / 1000:.1f}s" if ms else ""
         line = f"  {mark:<9} {job.get('key', '?')}{cross}{timing}"
@@ -75,7 +80,8 @@ 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 = "") -> str:
+              event: str = "", engine: str = "auto",
+              allow_side_effects: bool = False, network: str = "") -> str:
     """Route c3_ci actions."""
     project = str(svc.project_path)
     action = (action or "inspect").strip().lower()
@@ -85,7 +91,7 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
 
     # ── inspect ──────────────────────────────────────────────────────────
     if action in ("", "inspect", "jobs"):
-        data = inspect_project(project, event=event)
+        data = inspect_project(project, event=event, engine=engine)
         if not data["workflows"]:
             return finalize(
                 "c3_ci", args,
@@ -99,26 +105,39 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
             lines.append(f"  {wf['name']}  [{', '.join(wf['triggers']) or 'no triggers'}]"
                          f"  jobs={len(wf['jobs'])}{err}")
 
+        native = set(data.get("runnable_native") or [])
+        container = set(data.get("runnable_container") or [])
+
         lines.append("\nJob graph (dependency order):")
         by_key = {j["key"]: j for j in data["jobs"]}
         for key in data["order"]:
             j = by_key[key]
             needs = f"  needs={','.join(j['needs'])}" if j["needs"] else ""
-            if not j["supported"]:
+            if key in native:
+                state = "runnable here"
+            elif key in container:
+                state = "runnable (container)"
+            elif not j["supported"] and not j.get("act_could_run"):
                 state = "UNSUPPORTED"
-            elif j["foreign_runner"]:
-                state = f"other-OS ({j['runs_on']})"
             else:
-                state = "runnable here"
+                state = f"other-OS ({j['runs_on']})"
             lines.append(f"  {key:<42} {state}{needs}")
 
+        engines = data.get("engines") or {}
         lines.append(
-            f"\nRunnable on this host: {len(data['runnable'])} of {len(data['jobs'])}")
+            f"\nRunnable here: {len(data['runnable'])} of {len(data['jobs'])}"
+            f"  ({len(native)} native, {len(container)} container)")
+        if engines.get("ok"):
+            lines.append(f"  engines: native + act ({engines.get('act_version', '')})")
+        else:
+            lines.append(
+                f"  engines: native only — {engines.get('reason', 'act unavailable')}")
         if data["foreign"]:
             lines.append(
-                f"  other-OS ({len(data['foreign'])}): these target a different "
-                "runner. c3_ci(action='run', allow_foreign=true) attempts them "
-                "anyway and labels the result cross-OS.")
+                f"  other-OS ({len(data['foreign'])}): these target a runner no "
+                "available engine can reproduce. c3_ci(action='run', "
+                "allow_foreign=true) attempts them on this OS anyway and labels "
+                "the result cross-OS.")
         if data["unsupported"]:
             lines.append(f"  unsupported ({len(data['unsupported'])}):")
             for item in data["unsupported"][:8]:
@@ -151,7 +170,9 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
 
         result = cr.run_ci(project, selector=job, allow_foreign=allow_foreign,
                            only=only, timeout=timeout or cr.DEFAULT_STEP_TIMEOUT,
-                           workflow=workflow, event=event)
+                           workflow=workflow, event=event, engine=engine,
+                           allow_side_effects=allow_side_effects,
+                           network=network)
         run = result.to_dict()
         lines = [_verdict_line(run), f"run {run['run_id']}  host={run['host_os']}"]
         fp = run.get("fingerprint") or {}
@@ -224,6 +245,34 @@ 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")
 
+    # ── doctor ───────────────────────────────────────────────────────────
+    if action == "doctor":
+        from services import ci_act
+        state = ci_act.availability()
+        lines = [
+            "Local CI execution engines:",
+            "",
+            f"  native    available — runs jobs whose runs-on matches "
+            f"{cr.host_os()}",
+        ]
+        if state["ok"]:
+            lines += [
+                f"  act       available — {state['act_version']}, "
+                f"docker {state['docker_version']}",
+                f"            runs Linux jobs in a container "
+                f"({ci_act.DEFAULT_IMAGE}), real `uses:` actions included",
+            ]
+        else:
+            lines += ["  act       UNAVAILABLE", f"            {state['reason']}"]
+        lines += [
+            "",
+            "macOS jobs cannot run locally on any engine — there are no macOS "
+            "containers, so a matrix containing them can never reach "
+            "FULL_CI_PASS here.",
+        ]
+        return finalize("c3_ci", args, "\n".join(lines),
+                        "act ready" if state["ok"] else "act unavailable")
+
     return finalize("c3_ci", args,
                     f"Unknown action '{action}'. Use: inspect, run, rerun, "
-                    "status, failures, logs, runs.", "unknown action")
+                    "status, failures, logs, runs, doctor.", "unknown action")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.80.0
+Version: 2.82.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
@@ -202,7 +202,7 @@ C3 exposes **21 tools** as a native MCP server. Your IDE calls them directly:
 | `c3_session` | Snapshot, restore, log decisions, compact history |
 | `c3_impact` | Blast-radius analysis before editing shared symbols |
 | `c3_locks` | Agent leases — who is working on which file, so two agents don't collide (v2.65.0) |
-| `c3_ci` | Run this repo's real `.github/workflows` locally, with structured failures, before pushing (v2.79.0) |
+| `c3_ci` | Run this repo's real `.github/workflows` locally — in containers via `act` — with structured failures, before pushing (v2.79.0) |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini |
 | `c3_agent` | Workflows: `review_changes`, `investigate`, `preflight`, `prepare_context`, `validate_compress` |
 | `c3_edits` | Edit-ledger queries, version diffs, restore points, per-branch filter, `verify` (did a failed `c3_edit` still land?) |

{code_context_control-2.80.0 → code_context_control-2.82.0}/code_context_control.egg-info/SOURCES.txt

@@ -185,6 +185,7 @@ services/auto_memory.py
 services/benchmark_dashboard.py
 services/bitbucket_client.py
 services/bitbucket_credentials.py
+services/ci_act.py
 services/ci_expr.py
 services/ci_failures.py
 services/ci_runner.py
@@ -281,6 +282,7 @@ tests/test_bitbucket_tool.py
 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_expr.py
 tests/test_ci_runner.py
 tests/test_ci_workflow.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.80.0"
+version = "2.82.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"