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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: queue-watch
-Version: 0.2.0
+Version: 0.3.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
@@ -58,6 +58,7 @@ Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](htt
 queue-watch                              # inside a GitHub checkout
 queue-watch --repo owner/repo            # Actions plus the merge queue, if any
 queue-watch --profile work               # ~/.config/queue-watch/work.toml
+queue-watch profile add work --repo acme/api --repo acme/web
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
 queue-watch --demo                       # a simulated repository
@@ -65,7 +66,7 @@ queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs o
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
 
-With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the current Git checkout. Without one, it watches the checkout's GitHub repository: Actions runs, plus the merge queue when the default branch has one. `--profile NAME` reads `$XDG_CONFIG_HOME/queue-watch/NAME.toml` (default `~/.config`).
+With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the current Git checkout. Without one, it watches the checkout's GitHub repository: Actions runs, plus the merge queue when the default branch has one. Outside a GitHub checkout it opens the profile named `default`.
 
 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.
 
@@ -77,6 +78,19 @@ Keyboard: arrows to move, `1` to `9` for tabs, `/` to search (esc to clear), `o`
 
 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).
 
+### Profiles
+
+A profile is a named list of sources in `$XDG_CONFIG_HOME/queue-watch/NAME.toml` (default `~/.config`), so one dashboard can watch a group of repositories:
+
+```sh
+queue-watch profile add work --repo acme/api --repo acme/web   # creates or extends work.toml
+queue-watch profile list                                       # every profile and its sources
+queue-watch --profile work
+queue-watch profile add default --repo acme/api                # opens outside any checkout
+```
+
+`profile add` writes Actions for each repository, plus its merge queue when the default branch has one, with the repository's name in each label. Repositories already in the profile are left alone, and anything written by hand stays. A profile is ordinary [source config](#sources), so you can add `command` and `flock-queue` sources too. When a dashboard spans several repositories, a branch name such as `main` in two of them is two rows, each labelled with its repository.
+
 ### 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:
@@ -141,7 +155,7 @@ The program must exit zero and print one snapshot (below) on stdout within `time
 
 ## Snapshot contract
 
-Every adapter emits the same versioned snapshot (`queue-watch.snapshot/1`): a list of records with `id`, `kind`, `state` and `title`, plus optional `ref`, `sha`, `owner`, `position`, timestamps, `url`, `fields` and `children`. `state` is one of `queued`, `running`, `blocked`, `success`, `failure`, `cancelled`, `neutral` or `unknown`; the adapter's own term is kept in `raw_state`. Records that share a `ref` or `sha` describe the same change across sources. [`model.py`](https://github.com/wolfiesch/queue-watch/blob/main/src/queue_watch/model.py) defines and validates the contract, and `--once` prints it.
+Every adapter emits the same versioned snapshot (`queue-watch.snapshot/1`): a list of records with `id`, `kind`, `state` and `title`, plus optional `ref`, `sha`, `repo`, `owner`, `position`, timestamps, `url`, `fields` and `children`. `state` is one of `queued`, `running`, `blocked`, `success`, `failure`, `cancelled`, `neutral` or `unknown`; the adapter's own term is kept in `raw_state`. Records that share a `ref` or `sha` describe the same change across sources. Once records name more than one `repo` (`owner/name`, set by the GitHub adapters), a change also needs the same `repo`, and records without one join only each other; a `command` source watching several repositories should set it. [`model.py`](https://github.com/wolfiesch/queue-watch/blob/main/src/queue_watch/model.py) defines and validates the contract, and `--once` prints it.
 
 ## Development
 

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

@@ -31,6 +31,7 @@ Requires Python 3.11+. The GitHub adapters use an authenticated [GitHub CLI](htt
 queue-watch                              # inside a GitHub checkout
 queue-watch --repo owner/repo            # Actions plus the merge queue, if any
 queue-watch --profile work               # ~/.config/queue-watch/work.toml
+queue-watch profile add work --repo acme/api --repo acme/web
 queue-watch --config sources.toml        # any combination of sources
 queue-watch --repo owner/repo --once     # one JSON snapshot, no TUI
 queue-watch --demo                       # a simulated repository
@@ -38,7 +39,7 @@ queue-watch --theme nord --ascii         # another Textual theme; ASCII glyphs o
 queue-watch --density comfortable        # title, owner and PR on a second line
 ```
 
-With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the current Git checkout. Without one, it watches the checkout's GitHub repository: Actions runs, plus the merge queue when the default branch has one. `--profile NAME` reads `$XDG_CONFIG_HOME/queue-watch/NAME.toml` (default `~/.config`).
+With no flags, queue-watch looks for a `.queue-watch.toml` at the root of the current Git checkout. Without one, it watches the checkout's GitHub repository: Actions runs, plus the merge queue when the default branch has one. Outside a GitHub checkout it opens the profile named `default`.
 
 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.
 
@@ -50,6 +51,19 @@ Keyboard: arrows to move, `1` to `9` for tabs, `/` to search (esc to clear), `o`
 
 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).
 
+### Profiles
+
+A profile is a named list of sources in `$XDG_CONFIG_HOME/queue-watch/NAME.toml` (default `~/.config`), so one dashboard can watch a group of repositories:
+
+```sh
+queue-watch profile add work --repo acme/api --repo acme/web   # creates or extends work.toml
+queue-watch profile list                                       # every profile and its sources
+queue-watch --profile work
+queue-watch profile add default --repo acme/api                # opens outside any checkout
+```
+
+`profile add` writes Actions for each repository, plus its merge queue when the default branch has one, with the repository's name in each label. Repositories already in the profile are left alone, and anything written by hand stays. A profile is ordinary [source config](#sources), so you can add `command` and `flock-queue` sources too. When a dashboard spans several repositories, a branch name such as `main` in two of them is two rows, each labelled with its repository.
+
 ### 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:
@@ -114,7 +128,7 @@ The program must exit zero and print one snapshot (below) on stdout within `time
 
 ## Snapshot contract
 
-Every adapter emits the same versioned snapshot (`queue-watch.snapshot/1`): a list of records with `id`, `kind`, `state` and `title`, plus optional `ref`, `sha`, `owner`, `position`, timestamps, `url`, `fields` and `children`. `state` is one of `queued`, `running`, `blocked`, `success`, `failure`, `cancelled`, `neutral` or `unknown`; the adapter's own term is kept in `raw_state`. Records that share a `ref` or `sha` describe the same change across sources. [`model.py`](https://github.com/wolfiesch/queue-watch/blob/main/src/queue_watch/model.py) defines and validates the contract, and `--once` prints it.
+Every adapter emits the same versioned snapshot (`queue-watch.snapshot/1`): a list of records with `id`, `kind`, `state` and `title`, plus optional `ref`, `sha`, `repo`, `owner`, `position`, timestamps, `url`, `fields` and `children`. `state` is one of `queued`, `running`, `blocked`, `success`, `failure`, `cancelled`, `neutral` or `unknown`; the adapter's own term is kept in `raw_state`. Records that share a `ref` or `sha` describe the same change across sources. Once records name more than one `repo` (`owner/name`, set by the GitHub adapters), a change also needs the same `repo`, and records without one join only each other; a `command` source watching several repositories should set it. [`model.py`](https://github.com/wolfiesch/queue-watch/blob/main/src/queue_watch/model.py) defines and validates the contract, and `--once` prints it.
 
 ## Development
 

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

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

{queue_watch-0.2.0 → queue_watch-0.3.0}/src/queue_watch/adapters/github_actions.py

@@ -76,7 +76,7 @@ class GitHubActions(Adapter):
         return {
             "schema": SCHEMA,
             "observed_at": datetime.now(UTC).isoformat(),
-            "records": [self.record(run) for run in ordered],
+            "records": [{**self.record(run), "repo": self.repo} for run in ordered],
             "views": [
                 {
                     "kind": "run",

{queue_watch-0.2.0 → queue_watch-0.3.0}/src/queue_watch/adapters/github_merge_queue.py

@@ -82,7 +82,7 @@ class GitHubMergeQueue(Adapter):
                 warnings.append(
                     f"showing first {len(entries['nodes'])} of {entries['totalCount']} entries"
                 )
-            records = [self.record(entry) for entry in entries["nodes"]]
+            records = [{**self.record(entry), "repo": self.repo} for entry in entries["nodes"]]
         return {
             "schema": SCHEMA,
             "observed_at": datetime.now(UTC).isoformat(),

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

@@ -636,7 +636,8 @@ class QueueWatch(App):
         return bool(record.get("children")) or type(adapter).children is not Adapter.children
 
     def change_view(self, change: Change):
-        meta = [clean(change.ref or change.key)]
+        meta = [clean(change.repo)] if change.repo else []
+        meta.append(clean(change.ref or change.sha or change.key))
         if change.sha:
             meta.append(clean(change.sha)[:7])
         if change.pr:

{queue_watch-0.2.0 → queue_watch-0.3.0}/src/queue_watch/changes.py

@@ -1,7 +1,9 @@
 """Changes: records from every source that describe the same branch or commit.
 
 Records correlate by ``ref`` and fall back to ``sha``; records with neither stay
-in their source's own tab. Kinds with a role in a change: ``run`` (CI),
+in their source's own tab. When records name more than one ``repo``, the same ref
+in two repositories is two changes, and records without a ``repo`` form changes of
+their own. Kinds with a role in a change: ``run`` (CI),
 ``queue_entry`` (live merge queue position) and ``attempt`` (a finished merge
 attempt). Other kinds are only shown per source.
 """
@@ -51,6 +53,7 @@ class Change:
     key: str
     ref: str | None = None
     sha: str | None = None
+    repo: str | None = None  # set only when the snapshots span several repositories
     runs: list[Hit] = field(default_factory=list)  # newest first
     entries: list[Hit] = field(default_factory=list)  # queue order
     attempts: list[Hit] = field(default_factory=list)  # newest first
@@ -133,24 +136,36 @@ class Change:
 
 
 def correlate(snapshots: dict[str, dict]) -> list[Change]:
-    """One Change per ref (falling back to sha), in merge order, then most recent."""
-    by_ref: dict[str, Change] = {}
-    by_sha: dict[str, Change] = {}
+    """One Change per repository and ref (falling back to sha), in merge order, then
+    most recent. Repositories only separate changes when more than one appears."""
+    # GitHub repository names are case-insensitive.
+    repos = {
+        record["repo"].casefold()
+        for snapshot in snapshots.values()
+        for record in snapshot.get("records", [])
+        if record.get("repo")
+    }
+    several = len(repos) > 1
+    by_ref: dict[tuple[str | None, str], Change] = {}
+    by_sha: dict[tuple[str | None, str], Change] = {}
     changes: list[Change] = []
     for source, snapshot in snapshots.items():
         for record in snapshot.get("records", []):
             ref, sha = record.get("ref"), record.get("sha")
             if record["kind"] not in ROLES or not (ref or sha):
                 continue
-            change = (ref and by_ref.get(ref)) or (sha and by_sha.get(sha))
+            repo = (record.get("repo") or None) if several else None
+            scope = repo and repo.casefold()
+            change = (ref and by_ref.get((scope, ref))) or (sha and by_sha.get((scope, sha)))
             if not change:
-                change = Change(key=ref or sha)
+                name = ref or sha
+                change = Change(key=f"{scope}:{name}" if scope else name, repo=repo)
                 changes.append(change)
             if ref:
-                by_ref.setdefault(ref, change)
+                by_ref.setdefault((scope, ref), change)
                 change.ref = change.ref or ref
             if sha:
-                by_sha.setdefault(sha, change)
+                by_sha.setdefault((scope, sha), change)
                 change.sha = change.sha or sha
             hit = Hit(source, record)
             match record["kind"]:

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

@@ -5,11 +5,11 @@ with the wheel. Keyboard: tab/arrows, / search, r refresh, p pause, o open the
 selected record, q quit. Times are shown in America/Los_Angeles.
 
 With no source flags, queue-watch uses the repository's .queue-watch.toml once
-you have trusted it, and otherwise the current checkout's GitHub repository:
-Actions, plus the merge queue when the default branch has one. Nothing is ever
-changed: no reruns, cancellations, merges, lock acquisition or remote installs.
-Last good data stays visible on failure and is labelled stale. --once prints one
-JSON snapshot per source and exits nonzero when any source fails.
+you have trusted it, then the current checkout's GitHub repository (Actions, plus
+the merge queue when the default branch has one), then the profile named default.
+Nothing is ever changed: no reruns, cancellations, merges, lock acquisition or
+remote installs. Last good data stays visible on failure and is labelled stale.
+--once prints one JSON snapshot per source and exits nonzero when any source fails.
 
 Examples:
   queue-watch                               # inside a GitHub checkout
@@ -18,6 +18,8 @@ Examples:
   queue-watch --config sources.toml --once
   queue-watch trust                         # after reviewing .queue-watch.toml
   queue-watch --demo                        # simulated repository, no login needed
+  queue-watch profile add work --repo acme/api --repo acme/web
+  queue-watch profile list
 """
 
 from __future__ import annotations
@@ -31,7 +33,18 @@ from pathlib import Path
 
 from . import __version__
 from .config import ConfigError, Source, load
-from .discovery import CONFIG_NAME, detect, github_sources, profile_path, repo_config, trust
+from .discovery import (
+    CONFIG_NAME,
+    DEFAULT_PROFILE,
+    add_to_profile,
+    describe_profile,
+    detect,
+    github_sources,
+    profile_path,
+    profiles,
+    repo_config,
+    trust,
+)
 
 
 async def once(sources: list[Source]) -> int:
@@ -73,10 +86,53 @@ def trust_command(argv: list[str]) -> int:
     return 0
 
 
+def profile_command(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(
+        prog="queue-watch profile",
+        description="Manage profiles: named source lists under ~/.config/queue-watch. "
+        f"The {DEFAULT_PROFILE!r} profile is used outside a GitHub checkout.",
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+    add = commands.add_parser(
+        "add",
+        help="add GitHub repositories to a profile, creating it if needed",
+        description="Append Actions, plus the merge queue when the default branch has "
+        "one, for each repository. Repositories already in the profile are kept as they are.",
+    )
+    add.add_argument("name", help=f"profile name; {DEFAULT_PROFILE!r} is used outside a checkout")
+    add.add_argument(
+        "--repo", action="append", required=True, metavar="OWNER/REPO", help="repeatable"
+    )
+    commands.add_parser("list", help="list profiles and their sources")
+    args = parser.parse_args(argv)
+    if args.command == "list":
+        found = profiles()
+        if not found:
+            print(f"No profiles in {profile_path(DEFAULT_PROFILE).parent}.")
+            print("Create one: queue-watch profile add NAME --repo owner/repo")
+        for path in found:
+            note = "  (used outside a GitHub checkout)" if path.stem == DEFAULT_PROFILE else ""
+            print(f"{path.stem}{note}")
+            for line in describe_profile(path):
+                print(f"  {line}")
+        return 0
+    try:
+        path, added, skipped = asyncio.run(add_to_profile(args.name, args.repo))
+    except (ConfigError, OSError, UnicodeDecodeError) as error:
+        parser.error(str(error))
+    for repo in added:
+        print(f"Added {repo} to {path}")
+    for repo in skipped:
+        print(f"{repo} is already in {path}")
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = sys.argv[1:] if argv is None else argv
     if argv[:1] == ["trust"]:
         return trust_command(argv[1:])
+    if argv[:1] == ["profile"]:
+        return profile_command(argv[1:])
     parser = argparse.ArgumentParser(
         prog="queue-watch",
         description=__doc__,

queue_watch-0.3.0/src/queue_watch/discovery.py

@@ -0,0 +1,250 @@
+"""Where sources come from when no --repo or --config is given, and profiles.
+
+Order: a repository's own ``.queue-watch.toml`` (only once trusted), then the
+GitHub repository of the current checkout (Actions, plus its merge queue when the
+default branch has one), then the ``default`` profile.
+
+Profiles are the user's own TOML files under ``$XDG_CONFIG_HOME/queue-watch``.
+``queue-watch profile add NAME --repo owner/repo`` appends sources for each
+repository to one, keeping anything already written there.
+
+A repository config can run commands and open SSH connections, so a fresh clone
+must not be able to do either on its own. ``queue-watch trust`` records the
+SHA-256 of the file's exact bytes; any later edit needs trusting again, like
+``direnv allow``. Files passed with --config or --profile are the user's own and
+are trusted implicitly.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import tempfile
+import tomllib
+from pathlib import Path
+
+from .config import ConfigError, Source, build, load, parse
+
+CONFIG_NAME = ".queue-watch.toml"
+DEFAULT_PROFILE = "default"
+PROFILE_HEADER = """\
+# queue-watch profile: run with `queue-watch --profile {name}`.
+# Add repositories with `queue-watch profile add {name} --repo owner/repo`, or edit
+# by hand; https://github.com/wolfiesch/queue-watch lists every adapter's options.
+"""
+
+
+def state_dir() -> Path:
+    base = os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state"
+    return Path(base) / "queue-watch"
+
+
+def profile_dir() -> Path:
+    base = os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"
+    return Path(base) / "queue-watch"
+
+
+def profile_path(name: str) -> Path:
+    if not name or "/" in name or name.startswith("."):
+        raise ConfigError(f"profile must be a plain name, got {name!r}")
+    return profile_dir() / f"{name}.toml"
+
+
+def profiles() -> list[Path]:
+    return sorted(profile_dir().glob("*.toml"))
+
+
+def git_root(cwd: Path) -> Path | None:
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(cwd), "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            check=False,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return Path(result.stdout.strip()) if result.returncode == 0 else None
+
+
+def repo_config(cwd: Path) -> Path | None:
+    root = git_root(cwd)
+    if root is None:
+        return None
+    path = root / CONFIG_NAME
+    return path if path.is_file() else None
+
+
+def _store() -> Path:
+    return state_dir() / "trusted.json"
+
+
+def _trusted() -> dict[str, str]:
+    try:
+        data = json.loads(_store().read_text())
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def digest(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def trust(path: Path) -> list[Source]:
+    """Validate ``path`` and record its current bytes as trusted."""
+    path = path.resolve()
+    data = path.read_bytes()
+    sources = parse(data.decode(), path)  # Never trust a file that cannot load.
+    trusted = _trusted()
+    trusted[str(path)] = digest(data)
+    store = _store()
+    store.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile("w", dir=store.parent, delete=False) as handle:
+        json.dump(trusted, handle, indent=2, sort_keys=True)
+    os.replace(handle.name, store)
+    return sources
+
+
+def load_trusted(path: Path) -> list[Source]:
+    """Load a repository config only if these exact bytes were trusted."""
+    path = path.resolve()
+    data = path.read_bytes()  # Check and parse the same bytes.
+    recorded = _trusted().get(str(path))
+    if recorded != digest(data):
+        state = "changed since it was trusted" if recorded else "is not trusted yet"
+        raise ConfigError(
+            f"{path} {state}. It can run commands and open SSH connections. "
+            "Review it, then run: queue-watch trust"
+        )
+    return parse(data.decode(), path)
+
+
+def github_repo(cwd: Path) -> str | None:
+    try:
+        result = subprocess.run(
+            ["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
+            capture_output=True,
+            check=False,
+            text=True,
+            timeout=20,
+            cwd=cwd,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    name = result.stdout.strip()
+    return name if result.returncode == 0 and name else None
+
+
+async def detect(cwd: Path) -> list[Source]:
+    path = repo_config(cwd)
+    if path is not None:
+        return load_trusted(path)
+    repo = github_repo(cwd)
+    if repo is not None:
+        return await github_sources(repo)
+    default = profile_path(DEFAULT_PROFILE)
+    if default.is_file():
+        return load(default)
+    raise ConfigError(
+        "no sources found: not inside a GitHub checkout with an authenticated gh, "
+        f"no {CONFIG_NAME} and no default profile. Pass --repo, --config or --profile, "
+        "or create one: queue-watch profile add default --repo owner/repo"
+    )
+
+
+async def github_entries(repo: str, prefix: str = "") -> list[dict]:
+    """Source tables for Actions on ``repo``, plus its merge queue when the default
+    branch has one. ``prefix`` names the repository in ids and labels."""
+    from .adapters.github_merge_queue import has_queue
+
+    entries = [{"id": f"{prefix}ci", "adapter": "github-actions", "repo": repo}]
+    build(entries[0], repo)  # Reject a malformed repo before asking GitHub.
+    try:
+        queued = await has_queue(repo)
+    except (OSError, RuntimeError, ValueError, KeyError) as error:
+        raise ConfigError(f"cannot check {repo} for a merge queue: {error}") from error
+    if queued:
+        entries.append(
+            {"id": f"{prefix}merge-queue", "adapter": "github-merge-queue", "repo": repo}
+        )
+    if prefix:
+        name = repo.split("/")[1]
+        entries[0]["label"] = f"{name} CI"
+        if queued:
+            entries[1]["label"] = f"{name} merge queue"
+    return entries
+
+
+async def github_sources(repo: str) -> list[Source]:
+    """Actions for ``repo``, plus its merge queue when the default branch has one."""
+    return [build(entry, repo) for entry in await github_entries(repo)]
+
+
+def toml_table(entry: dict) -> str:
+    # JSON strings are valid TOML basic strings.
+    return "\n[[source]]\n" + "".join(
+        f"{key} = {json.dumps(value)}\n" for key, value in entry.items()
+    )
+
+
+async def add_to_profile(name: str, repos: list[str]) -> tuple[Path, list[str], list[str]]:
+    """Append GitHub sources for each new repository in ``repos`` to profile ``name``.
+
+    Returns the profile's path, the repositories added, and those it already had.
+    """
+    path = profile_path(name)
+    text = path.read_text() if path.exists() else PROFILE_HEADER.format(name=name)
+    try:
+        existing = tomllib.loads(text).get("source") or []
+    except tomllib.TOMLDecodeError as error:
+        raise ConfigError(f"{path}: {error}") from error
+    present = {
+        entry["repo"].casefold()
+        for entry in existing
+        if isinstance(entry, dict) and isinstance(entry.get("repo"), str)
+    }
+    ids = {entry.get("id") for entry in existing if isinstance(entry, dict)}
+    added, skipped = [], []
+    for repo in repos:
+        if repo.casefold() in present:
+            skipped.append(repo)
+            continue
+        prefix = base = repo.replace("/", "-").lower() + "-"
+        number = 2
+        while f"{prefix}ci" in ids or f"{prefix}merge-queue" in ids:  # a-b/c and a/b-c
+            prefix, number = f"{base}{number}-", number + 1
+        entries = await github_entries(repo, prefix)
+        text += "".join(map(toml_table, entries))
+        ids.update(entry["id"] for entry in entries)
+        present.add(repo.casefold())
+        added.append(repo)
+    if added:
+        parse(text, path)  # Never write a profile that cannot load.
+        target = path.resolve()  # Keep a symlinked profile (dotfiles) a symlink.
+        target.parent.mkdir(parents=True, exist_ok=True)
+        mode = target.stat().st_mode & 0o777 if target.exists() else 0o644
+        with tempfile.NamedTemporaryFile("w", dir=target.parent, delete=False) as handle:
+            handle.write(text)
+        os.chmod(handle.name, mode)
+        os.replace(handle.name, target)
+    return path, added, skipped
+
+
+def describe_profile(path: Path) -> list[str]:
+    """One line per source in a profile, without building any adapter."""
+    try:
+        entries = tomllib.loads(path.read_text()).get("source") or []
+    except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
+        return [f"cannot read: {error}"]
+    lines = []
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        target = entry.get("repo") or entry.get("host") or ""
+        label = entry.get("label") or entry.get("id") or "?"
+        lines.append(f"{label}  ({entry.get('adapter', '?')}{' ' + str(target) if target else ''})")
+    return lines or ["no sources"]

{queue_watch-0.2.0 → queue_watch-0.3.0}/src/queue_watch/model.py

@@ -13,11 +13,12 @@ A snapshot is one observation of one source:
 
 Record fields: ``id``, ``kind``, ``state`` and ``title`` are required. ``state`` is
 one of STATES; adapters keep their own vocabulary in ``raw_state``. ``ref`` and
-``sha`` identify the change so records from different sources can be correlated.
-Optional: ``raw_state``, ``subtitle``, ``ref``, ``sha``, ``owner``, ``position``
-(int), ``created_at``, ``updated_at``, ``started_at``, ``finished_at`` (ISO 8601),
-``url``, ``fields`` (JSON object for the inspector) and ``children`` (records,
-for example jobs and steps).
+``sha`` identify the change so records from different sources can be correlated;
+``repo`` ("owner/name") keeps equal refs from different repositories apart.
+Optional: ``raw_state``, ``subtitle``, ``ref``, ``sha``, ``repo``, ``owner``,
+``position`` (int), ``created_at``, ``updated_at``, ``started_at``, ``finished_at``
+(ISO 8601), ``url``, ``fields`` (JSON object for the inspector) and ``children``
+(records, for example jobs and steps).
 
 View: ``{"kind", "label", "columns": [{"key", "label", "width", "format"}]}``.
 A column key is a record field name or ``fields.<name>``; FORMATS lists formats.
@@ -43,7 +44,7 @@ ACTIVE = frozenset({"queued", "running", "blocked"})
 ATTENTION = frozenset({"failure", "blocked"})
 FORMATS = ("text", "state", "clock", "age", "seconds", "duration", "sha")
 TIME_FIELDS = ("created_at", "updated_at", "started_at", "finished_at")
-TEXT_FIELDS = ("raw_state", "subtitle", "ref", "sha", "owner", "url")
+TEXT_FIELDS = ("raw_state", "subtitle", "ref", "sha", "repo", "owner", "url")
 
 DEFAULT_VIEWS: dict[str, dict] = {
     "run": {

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

@@ -565,8 +565,10 @@ def change_cell(col: Column, change: Change, compact: bool) -> Content:
         case "glyph":
             return Content.assemble(glyph(change.state))
         case "ref":
-            name = change.ref or change.key[:7]
-            return Content.assemble((clean(name), "b"))
+            name = clean(change.ref or (change.sha or change.key)[:7])
+            if change.repo:  # several repositories: name the one this change is in
+                return Content.assemble(dim(clean(change.repo.split("/")[-1]) + " "), (name, "b"))
+            return Content.assemble((name, "b"))
         case "pr":
             return dim(f"#{change.pr}" if change.pr else "")
         case "title":

{queue_watch-0.2.0 → queue_watch-0.3.0}/tests/test_changes.py

@@ -81,3 +81,38 @@ def test_queue_state_outranks_green_ci_and_finished_changes_fall_to_done() -> No
         "queued": ["first"],
         "done": ["gone", "merged"],
     }
+
+
+def test_same_branch_in_different_repositories_stays_apart() -> None:
+    api = snap(
+        record("r1", "run", "success", ref="main", sha="a1", repo="acme/api"),
+        record("r2", "run", "failure", ref="feat/x", sha="a2", repo="acme/api"),
+    )
+    web = snap(record("r3", "run", "failure", ref="main", sha="b1", repo="acme/web"))
+    # A source without repositories (a command adapter) cannot be placed in either.
+    local = snap(record("q1", "queue_entry", "queued", ref="main", position=1))
+    changes = correlate({"api": api, "web": web, "local": local})
+    by_key = {change.key: change for change in changes}
+    assert set(by_key) == {"acme/api:main", "acme/api:feat/x", "acme/web:main", "main"}
+    assert by_key["acme/web:main"].state == "failure"
+    assert by_key["acme/api:main"].state == "success"
+    assert (by_key["acme/web:main"].repo, by_key["main"].repo) == ("acme/web", None)
+
+    # Repository names are case-insensitive; an empty one is no repository.
+    mixed = snap(
+        record("q2", "queue_entry", "queued", ref="main", repo="Acme/Web", position=1),
+        record("q3", "queue_entry", "queued", ref="main", repo="", position=2),
+    )
+    changes = correlate({"api": api, "web": web, "mixed": mixed})
+    assert sorted((c.key, len(c.runs), len(c.entries)) for c in changes) == [
+        ("acme/api:feat/x", 1, 0),
+        ("acme/api:main", 1, 0),
+        ("acme/web:main", 1, 1),
+        ("main", 0, 1),
+    ]
+
+    # With one repository, records without one still join it, and keys stay plain.
+    changes = correlate({"api": snap(api["records"][0]), "local": local})
+    assert [(change.key, change.repo, len(change.entries)) for change in changes] == [
+        ("main", None, 1)
+    ]

queue_watch-0.3.0/tests/test_discovery.py

@@ -0,0 +1,148 @@
+"""Source discovery: repository config trust, profiles, GitHub fallback."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+
+import pytest
+
+from queue_watch import cli, discovery
+from queue_watch.adapters import github_merge_queue
+from queue_watch.config import ConfigError
+
+CONFIG = '[[source]]\nid = "ci"\nadapter = "github-actions"\nrepo = "o/r"\n'
+
+
+@pytest.fixture
+def checkout(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / "state"))
+    repo = tmp_path / "repo"
+    (repo / "sub").mkdir(parents=True)
+    subprocess.run(["git", "init", "-q", str(repo)], check=True)
+    return repo
+
+
+def test_repo_config_needs_trust_and_retrust_after_any_edit(checkout):
+    path = checkout / discovery.CONFIG_NAME
+    path.write_text(CONFIG)
+    with pytest.raises(ConfigError, match="is not trusted yet.*queue-watch trust"):
+        asyncio.run(discovery.detect(checkout / "sub"))
+
+    discovery.trust(path)
+    (source,) = asyncio.run(discovery.detect(checkout / "sub"))
+    assert source.id == "ci"
+
+    path.write_text(CONFIG.replace('"ci"', '"build"'))
+    with pytest.raises(ConfigError, match="changed since it was trusted"):
+        asyncio.run(discovery.detect(checkout))
+
+
+def test_a_config_that_cannot_load_is_never_trusted(checkout):
+    path = checkout / discovery.CONFIG_NAME
+    path.write_text('[[source]]\nid = "a"\nadapter = "jenkins"\n')
+    with pytest.raises(ConfigError, match="adapter must be one of"):
+        discovery.trust(path)
+    assert not (checkout.parent / "state" / "queue-watch" / "trusted.json").exists()
+
+
+def test_trust_command_trusts_the_checkout_config(checkout, monkeypatch, capsys):
+    (checkout / discovery.CONFIG_NAME).write_text(CONFIG)
+    monkeypatch.chdir(checkout / "sub")
+    assert cli.main(["trust"]) == 0
+    assert "ci: github-actions" in capsys.readouterr().out
+    assert len(asyncio.run(discovery.detect(checkout))) == 1
+
+
+@pytest.mark.parametrize("queued", [True, False])
+def test_github_fallback_adds_merge_queue_only_when_present(checkout, monkeypatch, queued):
+    async def has_queue(repo):
+        assert repo == "o/r"
+        return queued
+
+    monkeypatch.setattr(discovery, "github_repo", lambda cwd: "o/r")
+    monkeypatch.setattr(github_merge_queue, "has_queue", has_queue)
+    sources = asyncio.run(discovery.detect(checkout))
+    expected = ["github-actions", "github-merge-queue"] if queued else ["github-actions"]
+    assert [source.adapter.name for source in sources] == expected
+
+
+def test_no_checkout_and_no_config_names_every_option(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
+    monkeypatch.setattr(discovery, "github_repo", lambda cwd: None)
+    with pytest.raises(ConfigError, match="--repo, --config or --profile.*profile add default"):
+        asyncio.run(discovery.detect(tmp_path))
+
+
+def test_default_profile_is_used_only_outside_a_github_checkout(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
+    (tmp_path / "config" / "queue-watch").mkdir(parents=True)
+    discovery.profile_path("default").write_text(CONFIG.replace("o/r", "acme/default"))
+    monkeypatch.setattr(github_merge_queue, "has_queue", lambda repo: asyncio.sleep(0, False))
+
+    monkeypatch.setattr(discovery, "github_repo", lambda cwd: None)
+    assert [s.adapter.repo for s in asyncio.run(discovery.detect(tmp_path))] == ["acme/default"]
+    monkeypatch.setattr(discovery, "github_repo", lambda cwd: "acme/here")
+    assert [s.adapter.repo for s in asyncio.run(discovery.detect(tmp_path))] == ["acme/here"]
+
+
+def test_profiles_live_under_xdg_config_home(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    assert discovery.profile_path("work") == tmp_path / "queue-watch" / "work.toml"
+    for bad in ("../work", ".hidden", ""):
+        with pytest.raises(ConfigError, match="plain name"):
+            discovery.profile_path(bad)
+
+
+def test_profile_add_appends_new_repositories_and_keeps_hand_edits(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+
+    async def has_queue(repo):
+        return repo == "acme/api"
+
+    monkeypatch.setattr(github_merge_queue, "has_queue", has_queue)
+    assert cli.main(["profile", "add", "work", "--repo", "acme/api", "--repo", "acme/web"]) == 0
+    path = discovery.profile_path("work")
+    path.write_text(path.read_text() + "# keep me\n")
+    assert cli.main(["profile", "add", "work", "--repo", "acme/web", "--repo", "Acme/Tools"]) == 0
+    out = capsys.readouterr().out
+    assert "acme/web is already in" in out and "Added Acme/Tools" in out
+
+    assert "# keep me" in path.read_text()
+    sources = discovery.load(path)
+    assert [(s.id, s.label, s.adapter.name, s.adapter.repo) for s in sources] == [
+        ("acme-api-ci", "api CI", "github-actions", "acme/api"),
+        ("acme-api-merge-queue", "api merge queue", "github-merge-queue", "acme/api"),
+        ("acme-web-ci", "web CI", "github-actions", "acme/web"),
+        ("acme-tools-ci", "Tools CI", "github-actions", "Acme/Tools"),
+    ]
+
+    assert cli.main(["profile", "list"]) == 0
+    listing = capsys.readouterr().out.splitlines()
+    assert listing[0] == "work" and "  api merge queue  (github-merge-queue acme/api)" in listing
+
+
+def test_profile_add_rejects_a_bad_repository_without_writing(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    with pytest.raises(SystemExit):
+        cli.main(["profile", "add", "work", "--repo", "not-a-repo"])
+    assert "owner/repo" in capsys.readouterr().err
+    assert not discovery.profile_path("work").exists()
+
+
+def test_profile_add_keeps_ids_unique_and_symlinks_and_mode_intact(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
+    monkeypatch.setattr(github_merge_queue, "has_queue", lambda repo: asyncio.sleep(0, False))
+    real = tmp_path / "dotfiles" / "work.toml"
+    real.parent.mkdir()
+    real.write_text(CONFIG)
+    real.chmod(0o640)
+    discovery.profile_dir().mkdir(parents=True)
+    discovery.profile_path("work").symlink_to(real)
+
+    path, added, skipped = asyncio.run(
+        discovery.add_to_profile("work", ["a-b/c", "a/b-c", "O/R", "a/B-C"])
+    )
+    assert (added, skipped) == (["a-b/c", "a/b-c"], ["O/R", "a/B-C"])
+    assert path.is_symlink() and real.stat().st_mode & 0o777 == 0o640
+    assert [s.id for s in discovery.load(path)] == ["ci", "a-b-c-ci", "a-b-c-2-ci"]

queue_watch-0.2.0/src/queue_watch/discovery.py

@@ -1,149 +0,0 @@
-"""Where sources come from when no --repo or --config is given.
-
-Order: a repository's own ``.queue-watch.toml`` (only once trusted), then the
-GitHub repository of the current checkout (Actions, plus its merge queue when the
-default branch has one).
-
-A repository config can run commands and open SSH connections, so a fresh clone
-must not be able to do either on its own. ``queue-watch trust`` records the
-SHA-256 of the file's exact bytes; any later edit needs trusting again, like
-``direnv allow``. Files passed with --config or --profile are the user's own and
-are trusted implicitly.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import os
-import subprocess
-import tempfile
-from pathlib import Path
-
-from .config import ConfigError, Source, build, parse
-
-CONFIG_NAME = ".queue-watch.toml"
-
-
-def state_dir() -> Path:
-    base = os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state"
-    return Path(base) / "queue-watch"
-
-
-def profile_path(name: str) -> Path:
-    if not name or "/" in name or name.startswith("."):
-        raise ConfigError(f"profile must be a plain name, got {name!r}")
-    base = os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"
-    return Path(base) / "queue-watch" / f"{name}.toml"
-
-
-def git_root(cwd: Path) -> Path | None:
-    try:
-        result = subprocess.run(
-            ["git", "-C", str(cwd), "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            check=False,
-            text=True,
-            timeout=10,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    return Path(result.stdout.strip()) if result.returncode == 0 else None
-
-
-def repo_config(cwd: Path) -> Path | None:
-    root = git_root(cwd)
-    if root is None:
-        return None
-    path = root / CONFIG_NAME
-    return path if path.is_file() else None
-
-
-def _store() -> Path:
-    return state_dir() / "trusted.json"
-
-
-def _trusted() -> dict[str, str]:
-    try:
-        data = json.loads(_store().read_text())
-    except (OSError, ValueError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def digest(data: bytes) -> str:
-    return hashlib.sha256(data).hexdigest()
-
-
-def trust(path: Path) -> list[Source]:
-    """Validate ``path`` and record its current bytes as trusted."""
-    path = path.resolve()
-    data = path.read_bytes()
-    sources = parse(data.decode(), path)  # Never trust a file that cannot load.
-    trusted = _trusted()
-    trusted[str(path)] = digest(data)
-    store = _store()
-    store.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.NamedTemporaryFile("w", dir=store.parent, delete=False) as handle:
-        json.dump(trusted, handle, indent=2, sort_keys=True)
-    os.replace(handle.name, store)
-    return sources
-
-
-def load_trusted(path: Path) -> list[Source]:
-    """Load a repository config only if these exact bytes were trusted."""
-    path = path.resolve()
-    data = path.read_bytes()  # Check and parse the same bytes.
-    recorded = _trusted().get(str(path))
-    if recorded != digest(data):
-        state = "changed since it was trusted" if recorded else "is not trusted yet"
-        raise ConfigError(
-            f"{path} {state}. It can run commands and open SSH connections. "
-            "Review it, then run: queue-watch trust"
-        )
-    return parse(data.decode(), path)
-
-
-def github_repo(cwd: Path) -> str | None:
-    try:
-        result = subprocess.run(
-            ["gh", "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
-            capture_output=True,
-            check=False,
-            text=True,
-            timeout=20,
-            cwd=cwd,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    name = result.stdout.strip()
-    return name if result.returncode == 0 and name else None
-
-
-async def detect(cwd: Path) -> list[Source]:
-    path = repo_config(cwd)
-    if path is not None:
-        return load_trusted(path)
-    repo = github_repo(cwd)
-    if repo is None:
-        raise ConfigError(
-            "no sources found: not inside a GitHub checkout with an authenticated gh, "
-            f"and no {CONFIG_NAME}. Pass --repo, --config or --profile."
-        )
-    return await github_sources(repo)
-
-
-async def github_sources(repo: str) -> list[Source]:
-    """Actions for ``repo``, plus its merge queue when the default branch has one."""
-    from .adapters.github_merge_queue import has_queue
-
-    sources = [build({"id": "ci", "adapter": "github-actions", "repo": repo}, repo)]
-    try:
-        queued = await has_queue(repo)
-    except (OSError, RuntimeError, ValueError, KeyError) as error:
-        raise ConfigError(f"cannot check {repo} for a merge queue: {error}") from error
-    if queued:
-        sources.append(
-            build({"id": "merge-queue", "adapter": "github-merge-queue", "repo": repo}, repo)
-        )
-    return sources

queue_watch-0.2.0/tests/test_discovery.py

@@ -1,81 +0,0 @@
-"""Source discovery: repository config trust, profiles, GitHub fallback."""
-
-from __future__ import annotations
-
-import asyncio
-import subprocess
-
-import pytest
-
-from queue_watch import cli, discovery
-from queue_watch.adapters import github_merge_queue
-from queue_watch.config import ConfigError
-
-CONFIG = '[[source]]\nid = "ci"\nadapter = "github-actions"\nrepo = "o/r"\n'
-
-
-@pytest.fixture
-def checkout(tmp_path, monkeypatch):
-    monkeypatch.setenv("XDG_STATE_HOME", str(tmp_path / "state"))
-    repo = tmp_path / "repo"
-    (repo / "sub").mkdir(parents=True)
-    subprocess.run(["git", "init", "-q", str(repo)], check=True)
-    return repo
-
-
-def test_repo_config_needs_trust_and_retrust_after_any_edit(checkout):
-    path = checkout / discovery.CONFIG_NAME
-    path.write_text(CONFIG)
-    with pytest.raises(ConfigError, match="is not trusted yet.*queue-watch trust"):
-        asyncio.run(discovery.detect(checkout / "sub"))
-
-    discovery.trust(path)
-    (source,) = asyncio.run(discovery.detect(checkout / "sub"))
-    assert source.id == "ci"
-
-    path.write_text(CONFIG.replace('"ci"', '"build"'))
-    with pytest.raises(ConfigError, match="changed since it was trusted"):
-        asyncio.run(discovery.detect(checkout))
-
-
-def test_a_config_that_cannot_load_is_never_trusted(checkout):
-    path = checkout / discovery.CONFIG_NAME
-    path.write_text('[[source]]\nid = "a"\nadapter = "jenkins"\n')
-    with pytest.raises(ConfigError, match="adapter must be one of"):
-        discovery.trust(path)
-    assert not (checkout.parent / "state" / "queue-watch" / "trusted.json").exists()
-
-
-def test_trust_command_trusts_the_checkout_config(checkout, monkeypatch, capsys):
-    (checkout / discovery.CONFIG_NAME).write_text(CONFIG)
-    monkeypatch.chdir(checkout / "sub")
-    assert cli.main(["trust"]) == 0
-    assert "ci: github-actions" in capsys.readouterr().out
-    assert len(asyncio.run(discovery.detect(checkout))) == 1
-
-
-@pytest.mark.parametrize("queued", [True, False])
-def test_github_fallback_adds_merge_queue_only_when_present(checkout, monkeypatch, queued):
-    async def has_queue(repo):
-        assert repo == "o/r"
-        return queued
-
-    monkeypatch.setattr(discovery, "github_repo", lambda cwd: "o/r")
-    monkeypatch.setattr(github_merge_queue, "has_queue", has_queue)
-    sources = asyncio.run(discovery.detect(checkout))
-    expected = ["github-actions", "github-merge-queue"] if queued else ["github-actions"]
-    assert [source.adapter.name for source in sources] == expected
-
-
-def test_no_checkout_and_no_config_names_every_option(tmp_path, monkeypatch):
-    monkeypatch.setattr(discovery, "github_repo", lambda cwd: None)
-    with pytest.raises(ConfigError, match="--repo, --config or --profile"):
-        asyncio.run(discovery.detect(tmp_path))
-
-
-def test_profiles_live_under_xdg_config_home(tmp_path, monkeypatch):
-    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
-    assert discovery.profile_path("work") == tmp_path / "queue-watch" / "work.toml"
-    for bad in ("../work", ".hidden", ""):
-        with pytest.raises(ConfigError, match="plain name"):
-            discovery.profile_path(bad)