code-coordinator 0.5.102__tar.gz → 0.5.104__tar.gz

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.102
+Version: 0.5.104
 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.102 → code_coordinator-0.5.104}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.102
+Version: 0.5.104
 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.104/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.104",
+  "distance": 0,
+  "node": "gafc1802780a563d8830320c477f8f5acd82577a6",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-16"
+}

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/coord/reports.py

@@ -59,6 +59,9 @@ __all__ = [
     "ReportParam",
     "ReportDef",
     "ColumnMeta",
+    "ChartSeries",
+    "ChartSpec",
+    "CHART_KINDS",
     "ReportResult",
     "REPORTS",
     "catalogue",
@@ -78,6 +81,7 @@ __all__ = [
     "QUEUE_OUTCOMES_WINDOW_CHOICES",
     "resolve_queue_outcomes_window",
     "fold_queue_outcomes",
+    "queue_outcomes_chart",
     "run_queue_outcomes",
     "parse_duration",
     "result_to_csv",
@@ -190,6 +194,90 @@ class ColumnMeta:
         }
 
 
+# ── chart declaration (#2271) ──────────────────────────────────────────────
+#
+# A report says "this table also reads as a chart"; it does NOT ship a second
+# copy of the numbers.  Every series names a `columns[]` id and the renderer
+# reads the same `rows` the table renders, so there is exactly one source of
+# truth, the table stays the fallback rendering, and `result_to_csv` (#1765)
+# needs no change at all — it is driven by `columns`/`rows`/`totals` and never
+# looks at this block.
+#
+# THE COMPATIBILITY RULE, same as `ColumnMeta.kind`'s (#1760): a client that
+# does not understand this block, or meets a `kind` it predates, **renders the
+# table and ignores the chart**.  It must never fail to parse and must never
+# leave a hole where the chart would have gone.  That matters more than usual
+# here because coord-tui ships as a per-host locally-built binary, outside
+# propagation's reach, so the fleet routinely runs mixed versions.
+
+#: Open vocabulary — the kinds a client is *expected* to know today.  A newer
+#: daemon may name one that is not here; see the compatibility rule above.
+CHART_KINDS = ("bar", "line", "sparkline")
+
+
+@dataclass(frozen=True)
+class ChartSeries:
+    """One series of a :class:`ChartSpec`, derived from an existing column.
+
+    ``column`` is a ``ReportResult.columns`` id whose per-row value supplies
+    the y-values; ``label`` is what the legend shows.  ``color`` is an
+    optional ``"#rrggbb"`` hint — when :attr:`ChartSpec.group_by` is set the
+    series are generated per group and the backend palette picks the colours
+    instead, because one declared colour cannot describe N groups.
+    """
+
+    label: str
+    column: str
+    color: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"label": self.label, "column": self.column, "color": self.color}
+
+
+@dataclass(frozen=True)
+class ChartSpec:
+    """An optional chart rendering of a :class:`ReportResult`'s own rows.
+
+    Two shapes, and which one you get depends on ``group_by``:
+
+    * **``group_by is None`` — one data point per row, in the report's
+      canonical row order.**  ``x`` names the column supplying each point's
+      category/time label; each :class:`ChartSeries` reads its own column
+      straight off the row.  This is the "one bar per category" shape.
+    * **``group_by`` set — a pivot.**  The x-axis is the *distinct* values of
+      ``x`` in first-appearance order, and one output series is produced per
+      distinct ``group_by`` value.  Rows landing in the same ``(group, x)``
+      cell are **summed**, and an empty cell is ``0`` — so this shape is for
+      magnitudes (counts, totals), not for averages or rates.  This is the
+      "one trendline per bucket" shape that a long-form result needs.
+
+    ``stacked`` is bar-only and ignored by every other kind.  Rendering a
+    multi-series bar chart at all needs quadraui#584; a client whose pinned
+    build predates it must degrade the section to a table with a stated
+    reason rather than draw a chart that silently omits every series but the
+    first.
+    """
+
+    kind: str
+    series: tuple[ChartSeries, ...]
+    x: str | None = None
+    group_by: str | None = None
+    stacked: bool = False
+    title: str = ""
+    y_label: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "series": [s.to_dict() for s in self.series],
+            "x": self.x,
+            "group_by": self.group_by,
+            "stacked": self.stacked,
+            "title": self.title,
+            "y_label": self.y_label,
+        }
+
+
 @dataclass
 class ReportResult:
     """The wire contract (#1741 renders against these exact field names).
@@ -210,6 +298,12 @@ class ReportResult:
     before.  Identity columns are deliberately *absent* from the dict rather
     than filled with a placeholder — a renderer that wants a ``Σ`` marker
     picks one itself, and one that doesn't leaves the cell blank.
+
+    ``chart`` (#2271) is an optional declaration that this result also reads
+    as a chart, derived from the very columns the table renders — see
+    :class:`ChartSpec`.  **Additive and defaulting to ``None``**, and a
+    client that ignores the key (or meets a ``kind`` it predates) renders the
+    table exactly as it did before.
     """
 
     report_id: str
@@ -220,6 +314,7 @@ class ReportResult:
     notes: list[str]
     column_meta: list[ColumnMeta] = field(default_factory=list)
     totals: dict[str, Any] | None = None
+    chart: ChartSpec | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -231,6 +326,7 @@ class ReportResult:
             "rows": list(self.rows),
             "notes": list(self.notes),
             "totals": None if self.totals is None else dict(self.totals),
+            "chart": None if self.chart is None else self.chart.to_dict(),
         }
 
 
@@ -1677,6 +1773,50 @@ def fold_queue_outcomes(
         rows=rows,
         notes=notes,
         totals=totals,
+        chart=queue_outcomes_chart(rows, n_periods),
+    )
+
+
+def queue_outcomes_chart(
+    rows: Sequence[Mapping[str, Any]], n_periods: int
+) -> ChartSpec | None:
+    """The chart declaration for a ``queue-outcomes`` fold (#2271).
+
+    Exactly the two views the report's own description already promises:
+    ``24h`` is a single period, so it is **one stacked bar per bucket** over
+    the categories in it; ``7d``/``4w`` are the same arithmetic in 7 daily /
+    4 weekly points, so they are **one trendline per bucket** over
+    ``period_start``.  Both derive from ``count`` — the column the table
+    renders — so there is nothing to keep in sync.
+
+    ``None`` when there is nothing to plot: an empty fold is an EMPTY result,
+    and an axis with no marks on it reads as a zero score rather than as no
+    measurement.
+    """
+    if not rows:
+        return None
+    if n_periods > 1:
+        return ChartSpec(
+            kind="line",
+            series=(ChartSeries(label="Entries", column="count"),),
+            x="period_start",
+            group_by="bucket",
+            title="Outcomes per period",
+            y_label="Entries",
+        )
+    # `x` and `group_by` are deliberately the same column. A terminal chart
+    # has a legend but no per-tick category text, so the legend is the only
+    # place a bucket NAME can appear — grouping on the axis column is what
+    # puts "succeeded / auto_resolved_* / human / open" on screen next to its
+    # own colour, instead of five anonymous bars.
+    return ChartSpec(
+        kind="bar",
+        series=(ChartSeries(label="Entries", column="count"),),
+        x="bucket",
+        group_by="bucket",
+        stacked=True,
+        title="Outcomes by bucket",
+        y_label="Entries",
     )
 
 

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/coord/serve_app.py

@@ -3566,6 +3566,10 @@ def _openapi_spec() -> dict:
                                             "type": ["object", "null"],
                                             "description": "#1763: optional grand-total row keyed by the same column ids as `rows`. `null` for reports with no meaningful sum (issue-activity, drive-queue-status); a client that ignores it renders exactly as before.",
                                         },
+                                        "chart": {
+                                            "type": ["object", "null"],
+                                            "description": "#2271: optional chart declaration — `kind` (open vocabulary: bar/line/sparkline), `series[]` each naming a `columns[]` id, `x`, `group_by`, `stacked`. It carries NO numbers of its own; the renderer reads the same `rows` the table does. A client that ignores the key, or meets a `kind` it predates, renders the table and no chart.",
+                                        },
                                     },
                                     "required": [
                                         "report_id", "generated_at", "window",

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/tests/test_reports.py

@@ -1098,10 +1098,12 @@ class TestCli:
         body = json.loads(result.output)
         assert set(body) == {
             "report_id", "generated_at", "window", "columns", "column_meta",
-            "rows", "notes", "totals",
+            "rows", "notes", "totals", "chart",
         }
         # #1763: additive and None for every report that has no meaningful sum.
         assert body["totals"] is None
+        # #2271: same posture for the chart declaration.
+        assert body["chart"] is None
         assert body["report_id"] == "issue-activity"
         assert body["window"] == [WINDOW[1] - 13 * 3600, WINDOW[1]]
 
@@ -1320,10 +1322,12 @@ class TestCliDriveQueueStatus:
         body = json.loads(result.output)
         assert set(body) == {
             "report_id", "generated_at", "window", "columns", "column_meta",
-            "rows", "notes", "totals",
+            "rows", "notes", "totals", "chart",
         }
         # #1763: additive and None for every report that has no meaningful sum.
         assert body["totals"] is None
+        # #2271: same posture for the chart declaration.
+        assert body["chart"] is None
         assert body["report_id"] == "drive-queue-status"
         assert body["window"][0] == body["window"][1]
         assert [m["id"] for m in body["column_meta"]] == body["columns"]
@@ -2180,7 +2184,7 @@ class TestUsageTotals:
             "column_meta", "rows", "notes",
         }
         payload = fold_issue_activity([], WINDOW).to_dict()
-        assert set(payload) == before | {"totals"}
+        assert set(payload) == before | {"totals", "chart"}
 
     def test_cli_table_renders_the_totals_row(self) -> None:
         from coord.commands.report import _render_table
@@ -3206,3 +3210,183 @@ class TestQueueOutcomesPartialWindow:
         )
         note = next(n for n in result.notes if n.startswith("PARTIAL WINDOW"))
         assert _abs_iso(QO_END - 3 * QO_DAY) in note
+
+
+# ── #2271: the chart declaration ───────────────────────────────────────────
+
+
+class TestChartDeclaration:
+    """The additive chart block on `ReportResult` (#2271).
+
+    The whole contract is "additive, and a client that does not understand it
+    renders the table" — so these tests are mostly about what did NOT change.
+    """
+
+    def test_chart_defaults_to_none_and_serialises_as_none(self) -> None:
+        result = ReportResult(
+            report_id="r",
+            generated_at=1.0,
+            window=(0.0, 1.0),
+            columns=["a"],
+            rows=[{"a": 1}],
+            notes=[],
+        )
+        assert result.chart is None
+        assert result.to_dict()["chart"] is None
+
+    def test_the_chart_key_is_additive_and_nothing_else_moved(self) -> None:
+        """The already-shipped #1741/#1763 panel deserialises the other eight
+        keys; adding `chart` must not disturb one of them."""
+        from coord.reports import ChartSeries, ChartSpec
+
+        plain = fold_issue_activity([], WINDOW).to_dict()
+        charted = fold_issue_activity([], WINDOW)
+        charted.chart = ChartSpec(
+            kind="line", series=(ChartSeries(label="L", column="issue"),), x="issue"
+        )
+        charted_payload = charted.to_dict()
+        assert set(charted_payload) == set(plain)
+        for key in plain:
+            if key != "chart":
+                assert charted_payload[key] == plain[key], key
+
+    def test_series_and_spec_wire_shape_is_pinned(self) -> None:
+        from coord.reports import ChartSeries, ChartSpec
+
+        spec = ChartSpec(
+            kind="bar",
+            series=(ChartSeries(label="Entries", column="count", color="#50a0f0"),),
+            x="category",
+            group_by="bucket",
+            stacked=True,
+            title="T",
+            y_label="Y",
+        )
+        assert spec.to_dict() == {
+            "kind": "bar",
+            "series": [
+                {"label": "Entries", "column": "count", "color": "#50a0f0"}
+            ],
+            "x": "category",
+            "group_by": "bucket",
+            "stacked": True,
+            "title": "T",
+            "y_label": "Y",
+        }
+
+    def test_series_defaults_leave_colour_unset(self) -> None:
+        from coord.reports import ChartSeries, ChartSpec
+
+        spec = ChartSpec(kind="line", series=(ChartSeries(label="L", column="c"),))
+        assert spec.to_dict() == {
+            "kind": "line",
+            "series": [{"label": "L", "column": "c", "color": None}],
+            "x": None,
+            "group_by": None,
+            "stacked": False,
+            "title": "",
+            "y_label": "",
+        }
+
+    def test_every_declared_series_column_exists_in_columns(self) -> None:
+        """The one invariant that makes "derive from existing columns" true:
+        a series naming a column the table does not carry would be a parallel
+        data block with extra steps."""
+        result = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        assert result.chart is not None
+        for series in result.chart.series:
+            assert series.column in result.columns
+        assert result.chart.x in result.columns
+        assert result.chart.group_by in result.columns
+
+    def test_csv_export_of_a_chart_bearing_report_is_unchanged(self) -> None:
+        """#1765's serializer is driven by columns/rows/totals and must not
+        grow a chart column, a chart comment, or anything else."""
+        from coord.reports import ChartSeries, ChartSpec
+
+        charted = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        assert charted.chart is not None
+        plain = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        plain.chart = None
+        assert result_to_csv(charted) == result_to_csv(plain)
+
+        # And a chart on a report that has none also changes nothing.
+        activity = fold_issue_activity([], WINDOW)
+        before = result_to_csv(activity)
+        activity.chart = ChartSpec(
+            kind="line", series=(ChartSeries(label="L", column="issue"),)
+        )
+        assert result_to_csv(activity) == before
+
+
+class TestQueueOutcomesChart:
+    def test_24h_declares_a_stacked_bar_over_buckets(self) -> None:
+        result = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        chart = result.chart
+        assert chart is not None
+        assert chart.kind == "bar"
+        assert chart.stacked is True
+        # Same column twice, on purpose: a terminal chart has no per-tick
+        # category text, so grouping on the axis column is what puts the
+        # bucket names in the legend instead of five anonymous bars.
+        assert chart.x == "bucket"
+        assert chart.group_by == "bucket"
+        assert [s.column for s in chart.series] == ["count"]
+
+    def test_7d_declares_a_trendline_per_bucket(self) -> None:
+        result = fold_queue_outcomes(
+            _qo_fixture(),
+            (QO_END - 7 * QO_DAY, QO_END),
+            period_seconds=QO_DAY,
+            merged=[],
+        )
+        chart = result.chart
+        assert chart is not None
+        assert chart.kind == "line"
+        assert chart.stacked is False
+        assert chart.x == "period_start"
+        assert chart.group_by == "bucket"
+
+    def test_4w_declares_a_trendline_too(self) -> None:
+        result = run_queue_outcomes(
+            window="4w",
+            now=QO_END,
+            location={"path": "p", "host": "h", "exists": True},
+            episode_source=_qo_fixture,
+            fetch=lambda **kw: {"entries": [], "has_more": False},
+        )
+        assert result.chart is not None
+        assert result.chart.kind == "line"
+
+    def test_an_empty_fold_declares_no_chart(self) -> None:
+        """An EMPTY result is not a zero score — an axis with no marks on it
+        reads as one, so there must be no chart to draw."""
+        result = fold_queue_outcomes([], (QO_END - QO_DAY, QO_END), merged=[])
+        assert result.rows == []
+        assert result.chart is None
+        assert result.to_dict()["chart"] is None
+
+    def test_the_chart_reaches_the_cli_json(self) -> None:
+        result = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        payload = json.loads(json.dumps(result.to_dict()))
+        assert payload["chart"]["kind"] == "bar"
+        assert payload["chart"]["series"][0]["column"] == "count"
+
+    def test_the_chart_never_carries_its_own_numbers(self) -> None:
+        """One source of truth: the block names columns, never values."""
+        result = fold_queue_outcomes(
+            _qo_fixture(), (QO_END - QO_DAY, QO_END), merged=[]
+        )
+        blob = json.dumps(result.to_dict()["chart"])
+        assert "data" not in blob
+        assert "values" not in blob

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/tui/Cargo.lock

@@ -1846,7 +1846,7 @@ checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
 [[package]]
 name = "quadraui"
 version = "0.0.1"
-source = "git+https://github.com/JDonaghy/quadraui?rev=e31258fc17b0b4490056a317686ada2278f9acc7#e31258fc17b0b4490056a317686ada2278f9acc7"
+source = "git+https://github.com/JDonaghy/quadraui?rev=d70da7dff7ef9f1eb578ee48aca69297e548348e#d70da7dff7ef9f1eb578ee48aca69297e548348e"
 dependencies = [
  "arboard",
  "gtk4",

{code_coordinator-0.5.102 → code_coordinator-0.5.104}/tui/Cargo.toml

@@ -54,7 +54,7 @@ test-support = []
 # quadraui checkout during co-development (a one-line, opt-in
 # `.cargo/config.toml` `paths` override — see
 # `tui/cargo-config-local-quadraui.toml.example`).
-quadraui = { git = "https://github.com/JDonaghy/quadraui", rev = "e31258fc17b0b4490056a317686ada2278f9acc7", features = ["tui", "terminal"] }
+quadraui = { git = "https://github.com/JDonaghy/quadraui", rev = "d70da7dff7ef9f1eb578ee48aca69297e548348e", features = ["tui", "terminal"] }
 rusqlite = { version = "0.32", features = ["bundled"] }
 serde_json = "1"
 serde = { version = "1", features = ["derive"] }