code-coordinator 0.5.307__tar.gz → 0.5.308__tar.gz

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.307
+Version: 0.5.308
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.307
+Version: 0.5.308
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/code_coordinator.egg-info/SOURCES.txt

@@ -445,6 +445,7 @@ tests/test_cli_diagnose_config_provenance.py
 tests/test_cli_diagnose_forge_availability.py
 tests/test_cli_diagnose_graph.py
 tests/test_cli_diagnose_self.py
+tests/test_cli_diagnose_test_coverage.py
 tests/test_cli_doctor.py
 tests/test_cli_doctor_config_free_1801.py
 tests/test_cli_doctor_config_mismatch_1712.py

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/code_coordinator.egg-info/scm_file_list.json

@@ -471,6 +471,7 @@
     "tests/test_cli_diagnose_forge_availability.py",
     "tests/test_cli_diagnose_graph.py",
     "tests/test_cli_diagnose_self.py",
+    "tests/test_cli_diagnose_test_coverage.py",
     "tests/test_cli_doctor.py",
     "tests/test_cli_doctor_config_free_1801.py",
     "tests/test_cli_doctor_config_mismatch_1712.py",

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.307",
+  "tag": "0.5.308",
   "distance": 0,
-  "node": "g82fe5f5ab0e0baa2d9fe5b79897b0aa0e7c3c889",
+  "node": "gde30a174fcc1e82cb10b2f750bbe379e349de5e4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-30"

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/coord/commands/status.py

@@ -1921,6 +1921,21 @@ def _diagnose_via_daemon(svc, params: dict) -> None:
         "network required."
     ),
 )
+@click.option(
+    "--test-coverage",
+    "test_coverage_check",
+    is_flag=True,
+    help=(
+        "#2967: report repos whose effective Test-stage command (same "
+        "ci_command > smoke_tests.default_command > test_command precedence "
+        "the Test gate itself uses) enables fewer cargo `--features` than "
+        "the repo's build_command — e.g. quadraui building "
+        "tui+gtk+terminal but testing only tui, so a `passed` verdict never "
+        "compiled the gtk/terminal code. Repos with no explicit "
+        "`--features` on either side are silently skipped (no signal). "
+        "Read-only, no checkout or network required."
+    ),
+)
 @click.option(
     "--self",
     "self_check",
@@ -1980,6 +1995,7 @@ def diagnose(
     graph_health: bool = False,
     config_provenance_check: bool = False,
     capability_rules_check: bool = False,
+    test_coverage_check: bool = False,
     self_check: bool = False,
     self_no_fetch: bool = False,
     forge_availability: bool = False,
@@ -2006,6 +2022,11 @@ def diagnose(
         _diagnose_capability_rules(config_path)
         return
 
+    # ── #2967: test_command feature-flag coverage vs build_command ──────────
+    if test_coverage_check:
+        _diagnose_test_coverage(config_path)
+        return
+
     # ── #2436: THIS process's own editable coord install freshness ──────────
     if self_check:
         _diagnose_self(fetch=not self_no_fetch)
@@ -2236,6 +2257,29 @@ def _diagnose_capability_rules(config_path: Path) -> None:
     click.echo(capability_rule_summary_line(findings, unclaimed))
 
 
+def _diagnose_test_coverage(config_path: Path) -> None:
+    """Report repos whose effective Test-stage command enables fewer cargo
+    ``--features`` than their ``build_command`` (#2967).
+
+    Read-only, local-machine only, same family as ``--capability-rules``.
+    Unlike ``--capability-rules`` this needs no repo checkout at all — it's
+    a pure comparison of two command strings already in ``coordinator.yml``
+    — so it reports identically wherever it's run, including a thin client
+    with no local checkouts (see ``coord/fleet_config_health.py``).
+    """
+    from coord.fleet_config_health import (  # noqa: PLC0415
+        feature_coverage_findings,
+        feature_coverage_summary_line,
+        format_feature_coverage_lines,
+    )
+
+    cfg = _load_config(config_path)
+    findings = feature_coverage_findings(cfg)
+    for line in format_feature_coverage_lines(findings):
+        click.echo(f"  {line}")
+    click.echo(feature_coverage_summary_line(findings))
+
+
 def _diagnose_self(*, fetch: bool) -> None:
     """Report whether THIS process's own editable ``coord`` install is
     behind origin (#2436).

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/coord/fleet_config_health.py

@@ -57,6 +57,7 @@ precedent as :func:`config_provenance` applies per repo.
 from __future__ import annotations
 
 import os
+import shlex
 import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -615,3 +616,166 @@ def capability_rule_summary_line(
         f"prefixes={len(findings)} dead={dead} partial={partial} "
         f"unclaimed_caps={len(unclaimed)}"
     )
+
+
+# ── Test-command feature-flag coverage vs build_command (#2967) ─────────────
+#
+# quadraui is configured `test_command: cargo test --features tui` against
+# `build_command: cargo build --features tui --features gtk --features
+# terminal` — the Test gate never compiles `src/gtk/**` or the terminal
+# backend, so a `passed` verdict on a change confined to either carries no
+# information at all. Nothing previously compared the two commands; this is
+# the same "config looks right in review but silently does less than it
+# claims" shape as #2953's dead capability_rules prefixes, one seam over:
+# there it was a `files` prefix matching nothing, here it's a `--features`
+# flag the build enables that the effective Test-stage command never turns
+# on. Pure string comparison against the already-loaded config — no local
+# checkout required, so (unlike `capability_rule_health`) this runs the same
+# everywhere, including a thin client with no repo checkouts at all.
+
+
+def _cargo_features(command: str | None) -> set[str]:
+    """Every value named by a `--features`/`-F`/`--features=...` token in
+    *command*, comma- or space-separated, deduped.
+
+    Returns the empty set for a falsy, unparseable (unbalanced quoting), or
+    feature-less command — treated as "no feature-flag signal to compare",
+    never as a gap by itself. That is what keeps a plain `cargo build` /
+    `cargo test` pair (vimcode, coord-tui) and non-cargo commands (npm/pnpm
+    repos) out of the findings entirely: both sides parse to an empty set,
+    which is equal, not missing.
+    """
+    if not command:
+        return set()
+    try:
+        tokens = shlex.split(command)
+    except ValueError:
+        return set()
+    features: set[str] = set()
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        value: str | None = None
+        if tok in ("--features", "-F"):
+            if i + 1 < len(tokens):
+                value = tokens[i + 1]
+                i += 1
+        elif tok.startswith("--features="):
+            value = tok[len("--features=") :]
+        if value is not None:
+            features.update(part for part in value.replace(",", " ").split() if part)
+        i += 1
+    return features
+
+
+@dataclass
+class FeatureCoverageFinding:
+    """Feature-flag coverage of one repo's effective Test-stage command
+    against its ``build_command`` (#2967).
+
+    ``effective_test_command``/``test_command_source``/``ci_equivalent``
+    mirror ``coord.smoke.resolve_smoke_command`` — the SAME precedence
+    (``ci_command`` > ``smoke_tests.default_command`` > ``test_command``)
+    the Test stage itself uses, so this reports on the command that will
+    actually gate the repo, not always the raw ``repos[].test_command``.
+    """
+
+    repo: str
+    build_command: str
+    effective_test_command: str | None
+    test_command_source: str
+    ci_equivalent: bool
+    build_features: tuple[str, ...] = ()
+    test_features: tuple[str, ...] = ()
+    missing_features: tuple[str, ...] = ()
+
+    @property
+    def gap(self) -> bool:
+        """``build_command`` enables a feature the effective test command
+        never turns on — a passed verdict didn't compile that code."""
+        return bool(self.missing_features)
+
+    @property
+    def healthy(self) -> bool:
+        return not self.gap
+
+
+def feature_coverage_findings(config: "Config") -> list[FeatureCoverageFinding]:
+    """Cargo `--features` coverage of every configured repo's effective
+    Test-stage command against its ``build_command`` (#2967).
+
+    Only repos whose ``build_command`` names at least one `--features` value
+    are considered — a repo with no explicit features (or a non-cargo build,
+    e.g. npm/pnpm) parses to an empty set on both sides and is silently
+    omitted, matching :func:`capability_rule_health`'s "no signal, no
+    finding" precedent. The effective test command is resolved with
+    ``coord.smoke.resolve_smoke_command`` (deferred import: `coord.smoke`
+    pulls in ``httpx``/``github_ops``, which this otherwise-light,
+    network-free module avoids at import time), so a repo that already
+    covers the gap via ``ci_command`` or ``smoke_tests.default_command``
+    correctly reports healthy rather than flagging the raw
+    ``test_command`` alone.
+    """
+    from coord.smoke import resolve_smoke_command  # noqa: PLC0415
+
+    findings: list[FeatureCoverageFinding] = []
+    for repo_cfg in config.repos:
+        build_command = repo_cfg.build_command
+        if not build_command:
+            continue
+        build_features = _cargo_features(build_command)
+        if not build_features:
+            continue
+        smoke_cmd = resolve_smoke_command(repo_cfg, config.smoke_tests)
+        test_features = _cargo_features(smoke_cmd.command)
+        missing = tuple(sorted(build_features - test_features))
+        findings.append(
+            FeatureCoverageFinding(
+                repo=repo_cfg.name,
+                build_command=build_command,
+                effective_test_command=smoke_cmd.command,
+                test_command_source=smoke_cmd.source,
+                ci_equivalent=smoke_cmd.ci_equivalent,
+                build_features=tuple(sorted(build_features)),
+                test_features=tuple(sorted(test_features)),
+                missing_features=missing,
+            )
+        )
+    return findings
+
+
+def format_feature_coverage_lines(findings: list[FeatureCoverageFinding]) -> list[str]:
+    """Human-readable report lines for *findings* (used by ``coord diagnose
+    --test-coverage``)."""
+    if not findings:
+        return [
+            "· no repo's build_command names an explicit `--features` value "
+            "— nothing to check (this only applies to cargo feature-flagged "
+            "builds)"
+        ]
+
+    lines: list[str] = []
+    for f in findings:
+        if f.gap:
+            lines.append(
+                f"✗ GAP: {f.repo} — build_command (`{f.build_command}`) enables "
+                f"[{', '.join(f.build_features)}], but the effective Test-stage "
+                f"command ({f.test_command_source}: "
+                f"`{f.effective_test_command or '(unconfigured)'}`) enables "
+                f"[{', '.join(f.test_features) or '(none)'}]. Missing: "
+                f"{', '.join(f.missing_features)} — a `passed` verdict never "
+                "compiled that code (#2967)."
+            )
+        else:
+            lines.append(
+                f"✓ {f.repo} — {f.test_command_source} covers every feature "
+                f"build_command enables ([{', '.join(f.build_features)}])"
+            )
+    return lines
+
+
+def feature_coverage_summary_line(findings: list[FeatureCoverageFinding]) -> str:
+    """The machine-readable trailer ``coord diagnose --test-coverage``
+    prints, mirroring ``GRAPH_HEALTH:``/``CAPABILITY_RULES:``."""
+    gap = sum(1 for f in findings if f.gap)
+    return f"TEST_COMMAND_COVERAGE: repos_checked={len(findings)} gap={gap}"

code_coordinator-0.5.308/tests/test_cli_diagnose_test_coverage.py

@@ -0,0 +1,153 @@
+"""End-to-end tests for `coord diagnose --test-coverage` — driven through the
+real Click command against real ``coordinator.yml`` files, asserting on
+rendered output (CLAUDE.md black-box coverage bar).
+
+#2967: quadraui is configured ``test_command: cargo test --features tui``
+against ``build_command: cargo build --features tui --features gtk
+--features terminal`` — the Test gate never compiles ``src/gtk/**`` or the
+terminal backend, so a `passed` verdict on a change confined to either
+carries no information at all. Nothing previously compared the two
+commands; this drives the CLI end to end against that exact live shape, plus
+the healthy/neutral cases that must NOT be flagged.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from coord.commands.status import diagnose
+
+
+def _write_config(tmp_path: Path, repos_yaml: str, *, smoke_tests_yaml: str = "") -> Path:
+    cfg = tmp_path / "coordinator.yml"
+    cfg.write_text(
+        "repos:\n"
+        f"{repos_yaml}"
+        "\n"
+        "machines:\n"
+        "  - name: desktop\n"
+        "    host: desktop.tailnet\n"
+        "    capabilities: [rust]\n"
+        "    repos: [quadraui]\n"
+        "    repo_paths:\n"
+        "      quadraui: ~/src/quadraui\n"
+        f"{smoke_tests_yaml}",
+        encoding="utf-8",
+    )
+    return cfg
+
+
+def _run(cfg: Path) -> str:
+    result = CliRunner().invoke(
+        diagnose, ["--test-coverage", "--config", str(cfg)], catch_exceptions=False
+    )
+    assert result.exit_code == 0, result.output
+    return result.output
+
+
+def test_reports_gap_for_the_live_quadraui_shape(tmp_path: Path) -> None:
+    """The exact live incident (#2967): build_command enables tui+gtk+terminal,
+    test_command enables only tui — gtk and terminal are missing and must be
+    named explicitly."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk --features terminal\"\n"
+        "    test_command: \"cargo test --features tui\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" in out
+    assert "quadraui" in out
+    assert "Missing: gtk, terminal" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=1" in out
+
+
+def test_healthy_when_test_command_covers_every_build_feature(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n"
+        "    test_command: \"cargo test --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=0" in out
+
+
+def test_ci_command_closing_the_gap_reports_healthy_not_the_raw_test_command(
+    tmp_path: Path,
+) -> None:
+    """`ci_command` outranks `test_command` for what the Test stage actually
+    runs (`coord.smoke.resolve_smoke_command`) — a repo that declares a wider
+    `ci_command` must report healthy even though its bare `test_command`
+    alone would be a gap."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n"
+        "    test_command: \"cargo test --features tui\"\n"
+        "    ci_command: \"cargo test --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "ci_command" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=0" in out
+
+
+def test_plain_cargo_build_and_test_with_no_features_is_not_flagged(tmp_path: Path) -> None:
+    """vimcode/coord-tui shape: neither command names `--features` at all —
+    nothing to compare, so the repo is silently omitted, not reported."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build\"\n"
+        "    test_command: \"cargo test\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "nothing to check" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=0 gap=0" in out
+
+
+def test_no_build_command_at_all_is_not_flagged(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    test_command: \"cargo test --features tui\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=0 gap=0" in out
+
+
+def test_unconfigured_test_command_reports_every_feature_missing(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" in out
+    assert "(unconfigured)" in out
+    assert "Missing: gtk, tui" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=1" in out

{code_coordinator-0.5.307 → code_coordinator-0.5.308}/tests/test_fleet_config_health.py

@@ -17,12 +17,16 @@ from coord.config import Config, SmokeRule, SmokeTestsConfig
 from coord.fleet_config_health import (
     CapabilityRuleFinding,
     ConfigProvenance,
+    FeatureCoverageFinding,
     capability_rule_health,
     capability_rule_summary_line,
     config_provenance,
     default_live_config_path,
     default_settings_dir,
+    feature_coverage_findings,
+    feature_coverage_summary_line,
     format_capability_rule_lines,
+    format_feature_coverage_lines,
     format_provenance_lines,
     local_repo_checkouts,
     summary_line,
@@ -669,4 +673,162 @@ def test_capability_rule_finding_dataclass_defaults_are_not_dead_or_healthy() ->
     assert f.checked_repos == ()
     assert f.dead is False
     assert f.partial is False
-    assert f.healthy is False
+
+
+# ── feature_coverage_findings: build_command vs effective test command (#2967) ──
+
+
+def test_test_command_coverage_flags_the_live_quadraui_shape() -> None:
+    """The exact live incident (#2967): build_command enables
+    tui+gtk+terminal, test_command enables only tui — gtk and terminal are
+    reported missing, and the finding says so explicitly."""
+    cfg = _config(
+        [
+            Repo(
+                name="quadraui",
+                github="acme/quadraui",
+                build_command="cargo build --features tui --features gtk --features terminal",
+                test_command="cargo test --features tui",
+            )
+        ],
+        [],
+    )
+
+    findings = feature_coverage_findings(cfg)
+
+    assert len(findings) == 1
+    f = findings[0]
+    assert f.repo == "quadraui"
+    assert f.build_features == ("gtk", "terminal", "tui")
+    assert f.test_features == ("tui",)
+    assert f.missing_features == ("gtk", "terminal")
+    assert f.gap is True
+    assert f.test_command_source == "repos[quadraui].test_command"
+    assert f.ci_equivalent is False
+
+    lines = format_feature_coverage_lines(findings)
+    joined = "\n".join(lines)
+    assert "GAP" in joined
+    assert "gtk, terminal" in joined
+    assert feature_coverage_summary_line(findings) == (
+        "TEST_COMMAND_COVERAGE: repos_checked=1 gap=1"
+    )
+
+
+def test_test_command_coverage_healthy_when_test_covers_every_build_feature() -> None:
+    cfg = _config(
+        [
+            Repo(
+                name="quadraui",
+                github="acme/quadraui",
+                build_command="cargo build --features tui --features gtk",
+                test_command="cargo test --features tui,gtk",
+            )
+        ],
+        [],
+    )
+
+    findings = feature_coverage_findings(cfg)
+
+    assert len(findings) == 1
+    assert findings[0].gap is False
+    assert findings[0].missing_features == ()
+    joined = "\n".join(format_feature_coverage_lines(findings))
+    assert "GAP" not in joined
+    assert "✓" in joined
+    assert feature_coverage_summary_line(findings) == (
+        "TEST_COMMAND_COVERAGE: repos_checked=1 gap=0"
+    )
+
+
+def test_test_command_coverage_prefers_ci_command_over_test_command() -> None:
+    """`ci_command` outranks `test_command` for the Test stage's actual
+    command (`coord.smoke.resolve_smoke_command`'s precedence) — a repo
+    whose `ci_command` closes the gap must report healthy even though its
+    bare `test_command` alone would be a gap."""
+    cfg = _config(
+        [
+            Repo(
+                name="quadraui",
+                github="acme/quadraui",
+                build_command="cargo build --features tui --features gtk",
+                test_command="cargo test --features tui",
+                ci_command="cargo test --features tui --features gtk",
+            )
+        ],
+        [],
+    )
+
+    findings = feature_coverage_findings(cfg)
+
+    assert len(findings) == 1
+    assert findings[0].gap is False
+    assert findings[0].ci_equivalent is True
+    assert findings[0].test_command_source == "repos[quadraui].ci_command"
+
+
+def test_test_command_coverage_skips_repos_with_no_explicit_features() -> None:
+    """vimcode/coord-tui shape: plain `cargo build`/`cargo test`, no
+    `--features` on either side — nothing to compare, so the repo is
+    silently omitted rather than reported as a (vacuous) match."""
+    cfg = _config(
+        [Repo(name="vimcode", github="acme/vimcode", build_command="cargo build",
+              test_command="cargo test")],
+        [],
+    )
+
+    assert feature_coverage_findings(cfg) == []
+    lines = format_feature_coverage_lines([])
+    assert lines == [
+        "· no repo's build_command names an explicit `--features` value "
+        "— nothing to check (this only applies to cargo feature-flagged "
+        "builds)"
+    ]
+    assert feature_coverage_summary_line([]) == "TEST_COMMAND_COVERAGE: repos_checked=0 gap=0"
+
+
+def test_test_command_coverage_skips_repos_with_no_build_command() -> None:
+    cfg = _config(
+        [Repo(name="quadraui", github="acme/quadraui", test_command="cargo test --features tui")],
+        [],
+    )
+
+    assert feature_coverage_findings(cfg) == []
+
+
+def test_test_command_coverage_unconfigured_test_command_is_a_full_gap() -> None:
+    cfg = _config(
+        [
+            Repo(
+                name="quadraui",
+                github="acme/quadraui",
+                build_command="cargo build --features tui --features gtk",
+            )
+        ],
+        [],
+    )
+
+    findings = feature_coverage_findings(cfg)
+
+    assert len(findings) == 1
+    f = findings[0]
+    assert f.gap is True
+    assert f.effective_test_command is None
+    assert f.missing_features == ("gtk", "tui")
+    joined = "\n".join(format_feature_coverage_lines(findings))
+    assert "(unconfigured)" in joined
+
+
+def test_test_coverage_finding_dataclass_defaults_are_not_a_gap() -> None:
+    """Sanity: a bare finding built with no `missing_features` is
+    (vacuously) healthy — `gap`/`healthy` key off `missing_features` alone,
+    not off whether `build_features`/`test_features` were populated."""
+    f = FeatureCoverageFinding(
+        repo="quadraui",
+        build_command="cargo build --features tui",
+        effective_test_command="cargo test --features tui",
+        test_command_source="repos[quadraui].test_command",
+        ci_equivalent=False,
+    )
+    assert f.gap is False
+    assert f.healthy is True