queue-watch 0.1.0__tar.gz → 0.2.0__tar.gz

{queue_watch-0.1.0 → queue_watch-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: queue-watch
-Version: 0.1.0
+Version: 0.2.0
 Summary: Read-only terminal dashboard for CI runs and merge queues, with mouse support
 Project-URL: Homepage, https://github.com/wolfiesch/queue-watch
 Project-URL: Issues, https://github.com/wolfiesch/queue-watch/issues
@@ -29,7 +29,19 @@ Description-Content-Type: text/markdown
 
 Read-only terminal dashboard for CI runs and merge queues. It joins records from every source into one row per change, so a branch's CI runs and its merge-queue entry read together, and draws each merge queue as a chain of chips in queue order. queue-watch never reruns, cancels, merges or takes a lock.
 
-![queue-watch showing a merge queue of four changes, the Changes table grouped by state, and the inspector for a failed change](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/screenshot.png)
+![queue-watch --demo: a merge queue landing changes one after another while CI runs finish, one fails and a fix goes through](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/demo.gif)
+
+Try it without a GitHub login:
+
+```sh
+uvx queue-watch --demo
+```
+
+## Why
+
+`gh run watch` follows one run, and GitHub's web UI shows Actions and the merge queue on separate pages. When several pull requests are queued at once, the questions are about the whole set: which one is merging now, which are waiting on checks, which failure is holding the queue up, and when the last one should land.
+
+queue-watch answers them on one screen for a whole repository and keeps refreshing on its own. It joins each change's CI runs and queue entry into one row, puts the attention cases first, and shows the queue in merge order with GitHub's estimates. It also watches queues GitHub never sees: a merge lock on a build host, or anything a short script can describe as JSON.
 
 ## Install
 
@@ -38,7 +50,7 @@ uv tool install queue-watch     # or: pipx install queue-watch
 uvx queue-watch                 # run once without installing
 ```
 
-Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](https://cli.github.com/) (`gh auth login`).
+Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](https://cli.github.com/) (`gh auth login`); `--demo` needs neither.
 
 ## Use
 
@@ -48,7 +60,8 @@ queue-watch --repo owner/repo            # Actions plus the merge queue, if any
 queue-watch --profile work               # ~/.config/queue-watch/work.toml
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
-queue-watch --theme nord --ascii         # any Textual theme; ASCII glyphs only
+queue-watch --demo                       # a simulated repository
+queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs only
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
 
@@ -56,10 +69,14 @@ With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the cu
 
 The Changes tab groups changes into Needs attention, Running, Queued and Done; every view a source reports also gets its own tab. Done starts folded while any other group has changes; press enter on a group row, or click it, to fold or unfold it. Select a change or a queue chip to see its CI checks, the jobs of the most notable one, its queue position and ETA, and recent history in the inspector.
 
+![queue-watch showing a merge queue of four changes, the Changes table grouped by state, and the inspector for a failed change](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/screenshot.png)
+
 Each merge queue gets a strip above the tabs: its entries in merge order, when it should clear, merges in the last hour, and how long recent attempts took. Queue depth over the session appears as a sparkline once two fetches have answered; sources report only the current queue, so the history starts when queue-watch does. On terminals under 30 rows the entries shrink to one line each.
 
 Keyboard: arrows to move, `1` to `9` for tabs, `/` to search (esc to clear), `o` to open the selection in a browser, `c` to copy its SHA, `d` to switch row density, `r` to refresh, `p` to pause, `q` to quit. The mouse works too: click tabs, rows, chips and the inspector buttons, and scroll with the wheel. When a source fails, its last good data stays on screen and its status pill turns stale.
 
+The default `queue-watch` theme draws on a black background and gives each region its own coloured box. Pass `--theme` with any Textual theme name, or pick one live from the command palette (ctrl+p).
+
 ### Repository configs need trust
 
 A config can run commands and open SSH connections, so a `.queue-watch.toml` that arrives with a clone does nothing until you review it and run:
@@ -134,7 +151,7 @@ uv run pytest -q                        # includes SVG snapshot tests
 uv run pytest -q --snapshot-update      # after an intended layout change
 ```
 
-`docs/screenshot.png` is the wide layout snapshot rendered in a browser. To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
+`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif` (needs Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
 
 ## License
 

{queue_watch-0.1.0 → queue_watch-0.2.0}/README.md

@@ -2,7 +2,19 @@
 
 Read-only terminal dashboard for CI runs and merge queues. It joins records from every source into one row per change, so a branch's CI runs and its merge-queue entry read together, and draws each merge queue as a chain of chips in queue order. queue-watch never reruns, cancels, merges or takes a lock.
 
-![queue-watch showing a merge queue of four changes, the Changes table grouped by state, and the inspector for a failed change](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/screenshot.png)
+![queue-watch --demo: a merge queue landing changes one after another while CI runs finish, one fails and a fix goes through](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/demo.gif)
+
+Try it without a GitHub login:
+
+```sh
+uvx queue-watch --demo
+```
+
+## Why
+
+`gh run watch` follows one run, and GitHub's web UI shows Actions and the merge queue on separate pages. When several pull requests are queued at once, the questions are about the whole set: which one is merging now, which are waiting on checks, which failure is holding the queue up, and when the last one should land.
+
+queue-watch answers them on one screen for a whole repository and keeps refreshing on its own. It joins each change's CI runs and queue entry into one row, puts the attention cases first, and shows the queue in merge order with GitHub's estimates. It also watches queues GitHub never sees: a merge lock on a build host, or anything a short script can describe as JSON.
 
 ## Install
 
@@ -11,7 +23,7 @@ uv tool install queue-watch     # or: pipx install queue-watch
 uvx queue-watch                 # run once without installing
 ```
 
-Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](https://cli.github.com/) (`gh auth login`).
+Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](https://cli.github.com/) (`gh auth login`); `--demo` needs neither.
 
 ## Use
 
@@ -21,7 +33,8 @@ queue-watch --repo owner/repo            # Actions plus the merge queue, if any
 queue-watch --profile work               # ~/.config/queue-watch/work.toml
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
-queue-watch --theme nord --ascii         # any Textual theme; ASCII glyphs only
+queue-watch --demo                       # a simulated repository
+queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs only
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
 
@@ -29,10 +42,14 @@ With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the cu
 
 The Changes tab groups changes into Needs attention, Running, Queued and Done; every view a source reports also gets its own tab. Done starts folded while any other group has changes; press enter on a group row, or click it, to fold or unfold it. Select a change or a queue chip to see its CI checks, the jobs of the most notable one, its queue position and ETA, and recent history in the inspector.
 
+![queue-watch showing a merge queue of four changes, the Changes table grouped by state, and the inspector for a failed change](https://raw.githubusercontent.com/wolfiesch/queue-watch/main/docs/screenshot.png)
+
 Each merge queue gets a strip above the tabs: its entries in merge order, when it should clear, merges in the last hour, and how long recent attempts took. Queue depth over the session appears as a sparkline once two fetches have answered; sources report only the current queue, so the history starts when queue-watch does. On terminals under 30 rows the entries shrink to one line each.
 
 Keyboard: arrows to move, `1` to `9` for tabs, `/` to search (esc to clear), `o` to open the selection in a browser, `c` to copy its SHA, `d` to switch row density, `r` to refresh, `p` to pause, `q` to quit. The mouse works too: click tabs, rows, chips and the inspector buttons, and scroll with the wheel. When a source fails, its last good data stays on screen and its status pill turns stale.
 
+The default `queue-watch` theme draws on a black background and gives each region its own coloured box. Pass `--theme` with any Textual theme name, or pick one live from the command palette (ctrl+p).
+
 ### Repository configs need trust
 
 A config can run commands and open SSH connections, so a `.queue-watch.toml` that arrives with a clone does nothing until you review it and run:
@@ -107,7 +124,7 @@ uv run pytest -q                        # includes SVG snapshot tests
 uv run pytest -q --snapshot-update      # after an intended layout change
 ```
 
-`docs/screenshot.png` is the wide layout snapshot rendered in a browser. To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
+`docs/screenshot.png` is the wide layout snapshot rendered in a browser; `uv run python docs/record_demo.py` re-records `docs/demo.gif` (needs Chrome and ffmpeg). To release, bump `__version__` in `src/queue_watch/__init__.py`, merge, and push a matching `vX.Y.Z` tag; the release workflow tests, builds, publishes to PyPI with trusted publishing, and creates the GitHub release.
 
 ## License
 

{queue_watch-0.1.0 → queue_watch-0.2.0}/src/queue_watch/__init__.py

@@ -1,3 +1,3 @@
 """Read-only terminal dashboard for CI runs and merge queues."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{queue_watch-0.1.0 → queue_watch-0.2.0}/src/queue_watch/app.py

@@ -22,6 +22,7 @@ from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
 from textual.content import Content
 from textual.events import Resize
+from textual.theme import Theme
 from textual.widgets import Button, DataTable, Footer, Input, Static, TabbedContent, TabPane
 
 from . import widgets
@@ -65,10 +66,40 @@ CHANGES = "changes-tab"
 CHILD_TTL = 15
 BAR = 8  # job duration bar cells; a job line fits the narrowest inspector
 
+# The default theme: a black backdrop like most terminals, with one hue per box (queue
+# strips use accent, the tabs primary, the inspector secondary) to give the screen structure.
+THEME = Theme(
+    name="queue-watch",
+    primary="#5FAFFF",
+    secondary="#AF87FF",
+    accent="#FF875F",
+    warning="#FFD75F",
+    error="#FF5F6D",
+    success="#5FD787",
+    foreground="#D4D4D4",
+    background="#000000",
+    surface="#000000",
+    panel="#000000",
+    dark=True,
+    variables={
+        "footer-background": "#000000",
+        "footer-key-foreground": "#FF875F",
+        "footer-description-foreground": "#9E9E9E",
+        "scrollbar": "#3A3A3A",
+        "scrollbar-hover": "#5A5A5A",
+        "scrollbar-active": "#5FAFFF",
+        "scrollbar-background": "#000000",
+        "scrollbar-background-hover": "#000000",
+        "scrollbar-background-active": "#000000",
+        "scrollbar-corner-color": "#000000",
+        "button-color-foreground": "#D4D4D4",
+    },
+)
+
 CSS = """
 Screen { background: $surface; }
 #status { height: 1; padding: 0 1; background: $panel; color: $foreground; }
-#status #brand { width: auto; margin-right: 2; color: $primary; }
+#status #brand { width: auto; margin-right: 2; color: $accent; }
 #status .pill { width: auto; padding: 0 1; margin-right: 1; }
 #status .pill.live { background: $success 25%; color: $text-success; }
 #status .pill.paused { background: $primary 20%; color: $text-primary; }
@@ -80,8 +111,18 @@ Screen { background: $surface; }
 .-narrow #status #counts-long { display: none; }
 .-narrow #status #counts-short { display: block; }
 
+/* One coloured, rounded box per region, titled in its top border. */
+.queue, #tabs, #inspector { border-title-style: bold; border-title-align: left; }
+.queue { border: round $accent 70%; border-title-color: $accent; }
+#tabs { border: round $primary 70%; border-title-color: $primary; }
+#inspector { border: round $secondary 70%; border-title-color: $secondary; }
+.-ascii .queue { border: ascii $accent 70%; }
+.-ascii #tabs { border: ascii $primary 70%; }
+.-ascii #inspector { border: ascii $secondary 70%; }
+.-short .queue { border: none; border-top: solid $accent 70%; }
+
 #queues { height: auto; }
-.queue { height: auto; padding: 0 1; border-bottom: solid $foreground 20%; }
+.queue { height: auto; padding: 0 1; }
 .queue-head { height: 1; }
 .queue-head .queue-title { width: auto; }
 .queue-head .queue-eta { width: 1fr; min-width: 18; padding-left: 2; }
@@ -121,7 +162,8 @@ Tabs { height: 2; }
 OptionList {
     height: 1fr; background: $surface; border: none; padding: 0; scrollbar-size-vertical: 1;
 }
-OptionList:focus { border: none; }
+OptionList:focus { border: none; background-tint: $foreground 0%; }
+DataTable:focus { background-tint: $foreground 0%; }
 OptionList > .option-list--option { padding: 0 1; }
 OptionList > .option-list--option-highlighted { background: $primary 28%; color: $foreground; text-style: none; }
 OptionList:focus > .option-list--option-highlighted { background: $primary 40%; color: $foreground; text-style: none; }
@@ -132,14 +174,14 @@ DataTable > .datatable--header { background: $panel; color: $text-muted; text-st
 DataTable > .datatable--cursor { background: $primary 30%; color: $foreground; }
 
 #inspector {
-    width: 32%; min-width: 40; max-width: 64; height: 1fr; padding: 0 1;
-    border-left: solid $foreground 20%; background: $surface; scrollbar-size-vertical: 1;
+    width: 32%; min-width: 42; max-width: 66; height: 1fr; padding: 0 1;
+    background: $surface; scrollbar-size-vertical: 1;
 }
 #insp-head { height: auto; padding-bottom: 1; }
 #insp-actions { height: auto; padding-bottom: 1; }
 #insp-actions Button { margin-right: 1; background: $primary 30%; color: $foreground; }
 #sections { height: auto; }
-.section-title { background: $panel; padding: 0 1; margin-top: 1; height: 1; }
+.section-title { background: $panel; color: $secondary; text-style: bold; padding: 0 1; margin-top: 1; height: 1; }
 .section-body { height: auto; padding: 0 1; }
 
 #notices { display: none; height: auto; max-height: 4; padding: 0 1; color: $text-warning; background: $panel; }
@@ -249,11 +291,12 @@ class QueueWatch(App):
         self,
         sources: list[Source],
         *,
-        theme: str = "tokyo-night",
+        theme: str = THEME.name,
         ascii: bool = False,
         density: str = "compact",
     ):
         super().__init__()
+        self.register_theme(THEME)
         self.sources = {source.id: source for source in sources}
         self.order = list(self.sources)
         self.initial_theme = theme

{queue_watch-0.1.0 → queue_watch-0.2.0}/src/queue_watch/cli.py

@@ -17,6 +17,7 @@ Examples:
   queue-watch --profile work                # ~/.config/queue-watch/work.toml
   queue-watch --config sources.toml --once
   queue-watch trust                         # after reviewing .queue-watch.toml
+  queue-watch --demo                        # simulated repository, no login needed
 """
 
 from __future__ import annotations
@@ -86,9 +87,12 @@ def main(argv: list[str] | None = None) -> int:
     group.add_argument("--repo", help="GitHub owner/repo: Actions plus any merge queue")
     group.add_argument("--config", type=Path, help="TOML file with [[source]] tables")
     group.add_argument("--profile", help="NAME for ~/.config/queue-watch/NAME.toml")
+    group.add_argument(
+        "--demo", action="store_true", help="simulated repository; no network or login"
+    )
     parser.add_argument("--once", action="store_true", help="print JSON once; no TUI")
     parser.add_argument(
-        "--theme", default="tokyo-night", help="Textual theme (default tokyo-night)"
+        "--theme", default="queue-watch", help="Textual theme (default queue-watch: black)"
     )
     parser.add_argument("--ascii", action="store_true", help="ASCII glyphs and borders only")
     parser.add_argument(
@@ -100,7 +104,13 @@ def main(argv: list[str] | None = None) -> int:
     )
     args = parser.parse_args(argv)
     try:
-        if args.config:
+        if args.demo:
+            from . import demo, widgets
+
+            clock = demo.Clock()
+            widgets.now = clock.now  # ages and estimates follow the simulated clock
+            sources = demo.sources(clock)
+        elif args.config:
             sources = load(args.config.expanduser())
         elif args.profile:
             sources = load(profile_path(args.profile))

queue_watch-0.2.0/src/queue_watch/demo.py

@@ -0,0 +1,306 @@
+"""``--demo``: a made-up repository whose CI and merge queue move on their own.
+
+Nothing touches the network. Simulated time runs at ``SPEED`` times the wall clock
+so a minute of watching shows several merges, a failed check and its fix. Events
+come from fixed patterns, so every run of the demo tells the same story.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+
+from .adapters import Adapter
+from .config import Source
+from .model import SCHEMA
+
+SPEED = 15  # simulated seconds per wall-clock second
+STEP = 30  # simulated seconds per tick
+WARMUP = 40  # ticks simulated before the first frame, so history exists
+REPO = "https://github.com/acme/widgets"
+NOTE = "Demo data: a simulated repository. Nothing here is real."
+
+PULLS = (
+    ("Stream large uploads", "feat/stream-upload", "dana"),
+    ("Cache parsed headers", "feat/parser-cache", "lee"),
+    ("Document merge queue", "docs/merge-queue", "sam"),
+    ("Fix font fallback on Windows", "fix/font-fallback", "ari"),
+    ("Faster diff rendering", "feat/diff-speed", "noor"),
+    ("Retry flaky socket reads", "fix/socket-retry", "kai"),
+    ("Bump lockfile", "chore/lockfile", "lee"),
+    ("Add CSV exporter", "feat/csv-export", "dana"),
+    ("Tidy error messages", "fix/errors", "sam"),
+    ("Theme tokens for dark mode", "feat/theme", "noor"),
+)
+ARRIVAL_GAPS = (2, 1, 3, 6, 7, 2, 3, 8)  # ticks between arrivals: bursts, then lulls
+CHECK_TICKS = (3, 5, 4, 6, 3)  # how long CI takes on a pull request
+FAILS_EVERY = 4  # every fourth pull request fails CI once, then gets a fix pushed
+FIX_AFTER = 5  # ticks between a failure and the fix being pushed
+MERGE_TICKS = (3, 4, 2, 3, 5)  # how long merging takes, by pull request
+MERGE_FAILS_EVERY = 6  # every sixth merge attempt fails and leaves the queue
+
+
+class Clock:
+    """Simulated epoch seconds, starting at the wall clock and running ``SPEED`` times faster."""
+
+    def __init__(self) -> None:
+        self.start = time.time()
+        self.origin = time.monotonic()
+
+    def now(self) -> float:
+        return self.start + (time.monotonic() - self.origin) * SPEED
+
+
+def iso(seconds: float) -> str:
+    return datetime.fromtimestamp(seconds, UTC).isoformat(timespec="seconds")
+
+
+def sha(*parts: object) -> str:
+    return hashlib.sha1("-".join(map(str, parts)).encode()).hexdigest()[:10]
+
+
+@dataclass
+class Run:
+    id: int
+    workflow: str
+    title: str
+    ref: str
+    sha: str
+    start: int  # tick
+    end: int  # tick the run finishes
+    outcome: str  # final state: success or failure
+
+    def state(self, tick: int) -> str:
+        return "running" if tick < self.end else self.outcome
+
+
+@dataclass
+class Entry:
+    number: int
+    title: str
+    ref: str
+    owner: str
+    joined: int
+    run: Run
+    fails: bool  # CI fails once before a fix lands
+    state: str = "checks"  # checks, queued, merging, blocked
+    since: int = 0  # tick the current state began
+
+    @property
+    def merge_ticks(self) -> int:
+        return MERGE_TICKS[self.number % len(MERGE_TICKS)]
+
+
+@dataclass
+class Simulation:
+    clock: Clock
+    epoch: float = 0.0  # simulated time of tick 0
+    tick: int = 0
+    pulls: int = 0
+    started: int = 0  # runs started, for unique run ids
+    merges: int = 0
+    next_arrival: int = 0
+    queue: list[Entry] = field(default_factory=list)
+    runs: list[Run] = field(default_factory=list)
+    attempts: list[dict] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        self.epoch = self.clock.now() - WARMUP * STEP
+        self.release = self.start_run("Release", "v2.4.0", "main", 2, 0, "blocked")
+        self.advance()
+
+    def at(self, tick: int) -> float:
+        return self.epoch + tick * STEP
+
+    def advance(self) -> None:
+        target = int((self.clock.now() - self.epoch) // STEP)
+        while self.tick < target:
+            self.tick += 1
+            self.step()
+
+    def start_run(self, workflow: str, title: str, ref: str, ticks: int, salt: int, outcome: str):
+        run = Run(
+            9100 + self.started, workflow, title, ref, sha(ref, salt), self.tick,
+            self.tick + ticks, outcome,
+        )  # fmt: skip
+        self.started += 1
+        self.runs.append(run)
+        return run
+
+    def step(self) -> None:
+        tick = self.tick
+        if tick >= self.next_arrival:
+            self.arrive()
+        for entry in self.queue:
+            if entry.state == "checks" and tick >= entry.run.end:
+                entry.state = "blocked" if entry.run.outcome == "failure" else "queued"
+                entry.since = tick
+            elif entry.state == "blocked" and tick - entry.since >= FIX_AFTER:
+                entry.fails = False
+                entry.run = self.start_run(
+                    "CI", entry.title, entry.ref, CHECK_TICKS[entry.number % len(CHECK_TICKS)],
+                    tick, "success",
+                )  # fmt: skip
+                entry.state, entry.since = "checks", tick
+        head = next((e for e in self.queue if e.state == "merging"), None)
+        if head and tick - head.since >= head.merge_ticks:
+            self.merges += 1
+            failed = self.merges % MERGE_FAILS_EVERY == 0
+            self.attempts.append(
+                {
+                    "id": f"attempt-{self.merges}",
+                    "kind": "attempt",
+                    "state": "failure" if failed else "success",
+                    "raw_state": "failed" if failed else "merged",
+                    "title": f"#{head.number} {head.title}",
+                    "ref": head.ref,
+                    "sha": head.run.sha,
+                    "owner": head.owner,
+                    "started_at": iso(self.at(head.since)),
+                    "finished_at": iso(self.at(tick)),
+                    "url": f"{REPO}/pull/{head.number}",
+                    "fields": {"pull_request": head.number},
+                }
+            )
+            self.queue.remove(head)
+            if not failed:
+                self.start_run("CI", f"Merge #{head.number}", "main", 3, tick, "success")
+            head = None
+        if head is None:
+            # Merges go in queue order; failed entries wait aside for their fix.
+            first = next((e for e in self.queue if e.state != "blocked"), None)
+            if first and first.state == "queued":
+                first.state, first.since = "merging", tick
+        del self.runs[: max(0, len(self.runs) - 14)]
+        del self.attempts[: max(0, len(self.attempts) - 40)]  # about an hour of merges
+        if self.release not in self.runs:
+            self.runs.insert(0, self.release)
+
+    def arrive(self) -> None:
+        title, ref, owner = PULLS[self.pulls % len(PULLS)]
+        number = 482 + self.pulls
+        fails = self.pulls % FAILS_EVERY == FAILS_EVERY - 1
+        ticks = CHECK_TICKS[self.pulls % len(CHECK_TICKS)]
+        run = self.start_run("CI", title, ref, ticks, self.tick, "failure" if fails else "success")
+        self.queue.append(Entry(number, title, ref, owner, self.tick, run, fails, since=self.tick))
+        self.next_arrival = self.tick + ARRIVAL_GAPS[self.pulls % len(ARRIVAL_GAPS)]
+        self.pulls += 1
+
+    def run_record(self, run: Run) -> dict:
+        state = run.outcome if run.outcome == "blocked" else run.state(self.tick)
+        lint_end = min(run.start + 1, run.end)
+        jobs = []
+        for name, start, end, outcome in (
+            ("lint", run.start, lint_end, "success"),
+            ("test (3.12)", run.start, run.end, run.outcome),
+        ):
+            done = self.tick >= end and outcome != "blocked"
+            job_state = outcome if done else ("queued" if outcome == "blocked" else "running")
+            job = {
+                "id": f"{run.id}-{name}",
+                "kind": "job",
+                "state": job_state,
+                "raw_state": job_state,
+                "title": name,
+                "started_at": iso(self.at(start)),
+                "fields": {"runner": "ubuntu-24.04"},
+            }
+            if done:
+                job["finished_at"] = iso(self.at(end))
+                job["fields"]["duration_seconds"] = (end - start) * STEP
+            jobs.append(job)
+        return {
+            "id": str(run.id),
+            "kind": "run",
+            "state": state,
+            "raw_state": {"running": "in_progress", "blocked": "waiting"}.get(state, state),
+            "title": run.workflow,
+            "subtitle": run.title,
+            "ref": run.ref,
+            "sha": run.sha,
+            "created_at": iso(self.at(run.start)),
+            "updated_at": iso(self.at(min(self.tick, run.end))),
+            "url": f"{REPO}/actions/runs/{run.id}",
+            "fields": {"run_id": run.id, "attempt": 1},
+            "children": jobs,
+        }
+
+    def entry_record(self, entry: Entry, position: int, eta: float | None) -> dict:
+        state, raw = {
+            "checks": ("queued", "awaiting_checks"),
+            "queued": ("queued", "queued"),
+            "merging": ("running", "merging"),
+            "blocked": ("blocked", "unmergeable"),
+        }[entry.state]
+        fields: dict = {"pull_request": entry.number}
+        if eta is not None:
+            fields["estimated_seconds"] = round(eta)
+        return {
+            "id": f"entry-{entry.number}",
+            "kind": "queue_entry",
+            "state": state,
+            "raw_state": raw,
+            "title": f"#{entry.number} {entry.title}",
+            "ref": entry.ref,
+            "sha": entry.run.sha,
+            "owner": entry.owner,
+            "position": position,
+            "created_at": iso(self.at(entry.joined)),
+            "url": f"{REPO}/pull/{entry.number}",
+            "fields": fields,
+        }
+
+    def ci(self) -> dict:
+        self.advance()
+        records = [self.run_record(run) for run in reversed(self.runs)]
+        return {"schema": SCHEMA, "observed_at": iso(self.clock.now()), "records": records}
+
+    def merge_queue(self) -> dict:
+        self.advance()
+        now = self.clock.now()
+        records, ahead = [], 0.0
+        for position, entry in enumerate(self.queue, 1):
+            eta = None
+            if entry.state == "merging":
+                ahead = max(0.0, self.at(entry.since + entry.merge_ticks) - now)
+                eta = ahead
+            elif entry.state != "blocked":
+                checks = max(0.0, self.at(entry.run.end) - now)
+                ahead = max(ahead, checks) + entry.merge_ticks * STEP
+                eta = ahead
+            records.append(self.entry_record(entry, position, eta))
+        return {
+            "schema": SCHEMA,
+            "observed_at": iso(now),
+            "records": records + self.attempts[::-1],
+            "note": NOTE,
+        }
+
+
+class DemoCI(Adapter):
+    name = "demo-ci"
+    label = "CI"
+
+    def __init__(self, simulation: Simulation) -> None:
+        self.simulation = simulation
+
+    async def snapshot(self) -> dict:
+        return self.simulation.ci()
+
+
+class DemoMergeQueue(DemoCI):
+    name = "demo-merge-queue"
+    label = "Merge queue"
+
+    async def snapshot(self) -> dict:
+        return self.simulation.merge_queue()
+
+
+def sources(clock: Clock) -> list[Source]:
+    simulation = Simulation(clock)
+    return [
+        Source("ci", DemoCI.label, 2, DemoCI(simulation)),
+        Source("merge-queue", DemoMergeQueue.label, 2, DemoMergeQueue(simulation)),
+    ]

{queue_watch-0.1.0 → queue_watch-0.2.0}/src/queue_watch/widgets.py

@@ -399,6 +399,7 @@ class QueueStrip(Vertical):
     def __init__(self, source: str, label: str) -> None:
         super().__init__(classes="queue")
         self.source, self.label = source, label
+        self.border_title = Content(clean(label))
         self.entries: list[dict] = []
         self.attempts: list[dict] = []  # with a duration: the "took" trend
         self.merges: list[float] = []  # finish times of every successful attempt
@@ -440,15 +441,13 @@ class QueueStrip(Vertical):
 
     def head(self) -> None:
         waiting = len(self.entries)
-        status = f"  {waiting} waiting"
+        status = f"{waiting} waiting"
         if not waiting:
-            status = "  nothing waiting"
+            status = "nothing waiting"
             if self.merges:
                 last = short_age(now() - max(self.merges))
                 status += f" {SYMBOLS.dot} last merge {last} ago"
-        self.query_one(".queue-title", Static).update(
-            Content.assemble((clean(self.label).upper(), "b"), muted(status))
-        )
+        self.query_one(".queue-title", Static).update(Content.assemble((status, "b")))
         clears = max((eta_of(e) or 0 for e in self.entries), default=0)
         self.query_one(".queue-eta", Static).update(
             Content.assemble(muted("clears in "), (eta_text(clears), "b")) if clears else ""
@@ -733,6 +732,7 @@ class Inspector(VerticalScroll):
 
     def __init__(self) -> None:
         super().__init__(id="inspector")
+        self.border_title = Content("inspector")
         self.pairs: list[tuple[Static, Static]] = []
 
     def compose(self) -> ComposeResult: