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

{code_context_control-2.81.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.81.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

{code_context_control-2.81.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.81.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":

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

@@ -1321,12 +1321,9 @@ def api_ci_inspect():
     except ValueError as e:
         return jsonify({"error": str(e)}), 404
     try:
-        from services import ci_act
-        data = inspect_project(resolved)
-        # The UI has to be able to say WHY a job cannot run here, and
-        # "install act" is a different answer from "macOS is impossible".
-        data["engines"] = ci_act.availability()
-        return jsonify(data)
+        # 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
 

{code_context_control-2.81.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 }) {
@@ -143,6 +148,9 @@ 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 (
@@ -152,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 }} />
@@ -289,13 +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 && !j.act_could_run) ? 'unsupported'
-                  : ((j.foreign_runner && !(j.act_could_run && engines && engines.ok))
-                    ? 'foreign' : 'passed')}
-                title={(!j.supported && !j.act_could_run) ? (j.blockers || []).join('; ')
-                  : (j.act_could_run && !j.supported ? 'the act engine can run this'
-                    : (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.81.0 → code_context_control-2.82.0}/cli/tools/ci.py

@@ -91,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,
@@ -105,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]:

{code_context_control-2.81.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.81.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

{code_context_control-2.81.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.81.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"

{code_context_control-2.81.0 → code_context_control-2.82.0}/services/ci_workflow.py

@@ -455,7 +455,11 @@ def instantiate(workflow: Workflow, event: str = "", git: dict = None) -> list:
             if job_if:
                 problem = ci_expr.validate(job_if, github_fields)
                 if problem:
+                    # Blocks on BOTH engines: act evaluates conditions too, and
+                    # a condition reading a value that does not exist locally
+                    # (no event) is unjudgeable whatever runs the job.
                     blockers.append(f"job-level {problem}")
+                    act_blockers.append(f"job-level {problem}")
 
             steps: list = []
             if not isinstance(steps_raw, list):
@@ -686,8 +690,19 @@ def build_dag(workflows, event: str = "", git: dict = None) -> Dag:
     return Dag(instances=instances)
 
 
-def inspect_project(project_path, event: str = "") -> dict:
-    """Everything `c3 ci inspect` needs, as plain data."""
+def inspect_project(project_path, event: str = "", engine: str = "auto") -> dict:
+    """Everything `c3 ci inspect` needs, as plain data.
+
+    Engine-aware on purpose. "Is this job runnable here?" has no answer until
+    you know what would run it: a Linux job is out of reach for the native
+    shell on Windows and routine for act. Reporting the native count alone
+    told users 3 of 15 when the real answer was 11 — so the partition is
+    computed once, here, and every surface (tool text, `--json`, the Hub)
+    reads the same numbers.
+
+    `engine='native'` forces the pre-act view, which is what a test wants when
+    it must not depend on whether act happens to be installed.
+    """
     files = discover_workflows(project_path)
     workflows = [parse_workflow(p) for p in files]
     dag = build_dag([w for w in workflows if not w.error],
@@ -699,18 +714,51 @@ def inspect_project(project_path, event: str = "") -> dict:
     except CycleError as exc:
         ordered, cycle = dag.instances, str(exc)
 
+    # Lazy: keeps parsing independent of the execution engines, and avoids
+    # paying for a `docker version` probe on every import.
+    from services import ci_act
+    engines = ci_act.availability() if engine in ("auto", "act") else {
+        "ok": False, "reason": "engine='native' — containers not considered"}
+    act_ok = bool(engines.get("ok"))
+
+    native, container, foreign, unsupported = [], [], [], []
+    for i in ordered:
+        is_linux = runner_os(i.runs_on) == "Linux"
+        can_native = i.supported_by("native") and not i.foreign_runner
+        can_container = act_ok and is_linux and i.supported_by("act")
+
+        if can_native:
+            native.append(i)
+        elif can_container:
+            container.append(i)
+        else:
+            # It cannot run. Two very different reasons, and conflating them
+            # sends the reader to the wrong fix: `unsupported` means the job
+            # contains something no available engine reproduces, `foreign`
+            # means the job is fine but its runner is out of reach. Judge the
+            # blockers of the engine that WOULD have been chosen.
+            would_use = "act" if (act_ok and is_linux) else "native"
+            if not i.supported_by(would_use):
+                unsupported.append(i)
+            else:
+                foreign.append(i)
+
     return {
         "project": str(project_path),
         "host_os": host_os(),
+        "engines": engines,
         "workflows": [w.to_dict() for w in workflows],
         "jobs": [i.to_dict() for i in ordered],
         "order": [i.key for i in ordered],
         "cycle": cycle,
         "unknown_needs": dag.unknown_needs(),
-        "runnable": [i.key for i in ordered
-                     if i.supported and not i.foreign_runner],
-        "unsupported": [{"key": i.key, "blockers": i.blockers}
-                        for i in ordered if not i.supported],
-        "foreign": [{"key": i.key, "runs_on": i.runs_on}
-                    for i in ordered if i.supported and i.foreign_runner],
+        # `runnable` is the union — what can actually run here, by any engine
+        # available. The two breakdowns say how.
+        "runnable": [i.key for i in native + container],
+        "runnable_native": [i.key for i in native],
+        "runnable_container": [i.key for i in container],
+        "unsupported": [{"key": i.key,
+                         "blockers": i.blockers_for("act" if act_ok else "native")}
+                        for i in unsupported],
+        "foreign": [{"key": i.key, "runs_on": i.runs_on} for i in foreign],
     }

{code_context_control-2.81.0 → code_context_control-2.82.0}/tests/test_ci_act.py

@@ -282,6 +282,74 @@ jobs:
         self.assertEqual((engine, fidelity), ("native", cr.FIDELITY_CROSS_OS))
 
 
+class TestInspectPartition(ActTempProject):
+    """The partition every surface reads — tool text, --json, and the Hub.
+
+    Regression: the Hub re-derived runnability in JavaScript 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. The fix was to compute this once, here,
+    and have the UI read it; these tests are what keep that true.
+    """
+
+    def _inspect(self, act_ok: bool):
+        workflow(self.tmp, """
+name: CI
+on: [push]
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo hi
+  mac:
+    runs-on: macos-latest
+    steps:
+      - run: echo hi
+  broken:
+    runs-on: ubuntu-latest
+    steps:
+      - run: deploy --token ${{ secrets.TOKEN }}
+""")
+        from services.ci_workflow import inspect_project
+        with mock.patch.object(ci_act, "availability",
+                               return_value={"ok": act_ok, "reason": "stubbed"}):
+            return inspect_project(self.tmp)
+
+    def test_macos_is_never_container_runnable_even_with_act(self):
+        data = self._inspect(act_ok=True)
+        mac = "CI::mac"
+        # Host-independent: act has no macOS image, so this can never be
+        # containerised anywhere. This is the claim the Hub bug violated.
+        self.assertNotIn(mac, data["runnable_container"])
+        if host_os() == "Darwin":
+            # On a Mac it is simply native — runnable, just not via a container.
+            self.assertIn(mac, data["runnable_native"])
+        else:
+            self.assertNotIn(mac, data["runnable"])
+            self.assertIn(mac, [f["key"] for f in data["foreign"]])
+
+    def test_linux_moves_from_foreign_to_container_when_act_appears(self):
+        if host_os() == "Linux":
+            self.skipTest("ubuntu-latest is native on a Linux host")
+        without = self._inspect(act_ok=False)
+        self.assertIn("CI::linux", [f["key"] for f in without["foreign"]])
+        with_act = self._inspect(act_ok=True)
+        self.assertIn("CI::linux", with_act["runnable_container"])
+
+    def test_a_job_blocked_on_every_engine_is_unsupported_not_foreign(self):
+        # A missing secret is not a reachability problem, and sending the
+        # reader to "install act" would be the wrong fix.
+        data = self._inspect(act_ok=True)
+        self.assertIn("CI::broken", [u["key"] for u in data["unsupported"]])
+        self.assertNotIn("CI::broken", [f["key"] for f in data["foreign"]])
+
+    def test_runnable_is_the_union_of_both_engines(self):
+        data = self._inspect(act_ok=True)
+        self.assertEqual(
+            sorted(data["runnable"]),
+            sorted(data["runnable_native"] + data["runnable_container"]))
+
+
 class TestAvailability(unittest.TestCase):
     def test_missing_act_reports_how_to_install_it(self):
         with mock.patch.object(ci_act, "find_act", return_value=""):

{code_context_control-2.81.0 → code_context_control-2.82.0}/tests/test_ci_runner.py

@@ -453,7 +453,7 @@ jobs:
         out, _ = self._call("inspect")
         self.assertIn("CI::lint", out)
         self.assertIn("needs=lint", out)
-        self.assertIn("Runnable on this host: 2 of 2", out)
+        self.assertIn("Runnable here: 2 of 2", out)
 
     def test_run_then_failures_then_rerun(self):
         workflow(self.tmp, f"""

{code_context_control-2.81.0 → code_context_control-2.82.0}/tests/test_ci_workflow.py

@@ -279,7 +279,11 @@ class TestInspectProject(CiTempProject):
                        f"    steps:\n      - run: echo ok\n"
                        f"  broken:\n    runs-on: self-hosted-unknown\n"
                        f"    steps:\n      - uses: exotic/thing@v1\n")
-        data = inspect_project(self.tmp)
+        # engine="native" pins the pre-container partition. With act installed
+        # the Linux job would be containerised instead of refused — correct,
+        # and covered in test_ci_act.py — but this test is about the native
+        # split and must not depend on what the machine happens to have.
+        data = inspect_project(self.tmp, engine="native")
         self.assertIn("CI::here", data["runnable"])
         self.assertIn("CI::elsewhere", [f["key"] for f in data["foreign"]])
         self.assertIn("CI::broken", [u["key"] for u in data["unsupported"]])