alissa-tools-github-devloop 0.1.0__py3-none-any.whl

alissa/tools/github/devloop/__init__.py

@@ -0,0 +1,11 @@
+"""devloop — a GitHub watcher that turns `alissa:develop`-labeled issues into
+fresh developer sessions: the developer-side counterpart of reviewloop.
+
+The moving parts: `config` (three-layer settings + reviewer rails),
+`ghclient` (gh api access, self-assignment in-flight marker), `state` (the
+attempt ledger), `loop` (the DevWatcher decision state machine and the
+DEV_DIRECTIVE contract), `alissa` (session queue + worker plumbing), and
+`__main__` (the alissa-devloop CLI).
+"""
+
+__all__: list[str] = []

alissa/tools/github/devloop/__main__.py

@@ -0,0 +1,217 @@
+"""CLI entry point: alissa-devloop (or python -m alissa.tools.github.devloop)"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import logging
+import sys
+from pathlib import Path
+
+from .config import (
+    HUB_ADD,
+    HUB_SKIP,
+    ON_MISSING_SKIP,
+    ON_MISSING_SPAWN,
+    ON_MISSING_WARN,
+    Config,
+    load_config_file,
+    resolve_config_path,
+    resolve_reviewers,
+)
+from .ghclient import IdentityMismatch, RateLimited
+from .loop import DevWatcher
+from .proc import CommandError
+from .version import version
+
+log = logging.getLogger(__name__)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="alissa-devloop",
+        description="Watch GitHub for alissa:develop-labeled issues and spawn "
+        "fresh developer sessions — the developer-side counterpart of "
+        "alissa-reviewloop.",
+        epilog="Every setting below can also live in the config file; CLI "
+        "arguments win, and ALISSA_DEV_REVIEWERS wins over --reviewer. "
+        "workspace_root is CLI-only, so one config can drive several daemons "
+        "over different workspaces.",
+    )
+
+    p.add_argument(
+        "--version", action="version", version=f"%(prog)s {version.value}"
+    )
+    p.add_argument(
+        "--workspace-root",
+        type=Path,
+        default=None,
+        metavar="PATH",
+        help="the Alissa Code Workspace to watch (default: current directory)",
+    )
+    p.add_argument(
+        "-c",
+        "--config-path",
+        "--config",
+        dest="config_path",
+        type=Path,
+        default=None,
+        metavar="PATH",
+        help="config file; without it, ./devloop.config.json then "
+        "<workspace-root>/devloop.config.json, else defaults only",
+    )
+
+    mode = p.add_argument_group("mode")
+    mode.add_argument("--once", action="store_true", help="run a single poll pass and exit")
+    mode.add_argument("-v", "--verbose", action="store_true")
+
+    over = p.add_argument_group("config overrides (win over the config file)")
+    over.add_argument(
+        "--repo",
+        dest="repos",
+        action="append",
+        metavar="OWNER/REPO",
+        help="watch this repo for labeled issues; repeatable. When given, "
+        "REPLACES the config `repos` list; when absent, the config list "
+        "applies. Emptying the allowlist (which turns the daemon off — an "
+        "empty allowlist watches NOTHING) is done in the config file.",
+    )
+    over.add_argument("--poll-interval", type=int, metavar="SECONDS")
+    over.add_argument("--label", metavar="LABEL", help="issue label that marks dev-ready work")
+    over.add_argument("--hub-template", metavar="TEMPLATE")
+    over.add_argument("--agent-profile", metavar="NAME")
+    over.add_argument("--developer-login", metavar="LOGIN")
+    over.add_argument(
+        "--reviewer",
+        dest="reviewers",
+        action="append",
+        metavar="LOGIN",
+        help="request this reviewer at the ready-for-review flip; repeatable. "
+        "Replaces the config list. ALISSA_DEV_REVIEWERS overrides even this.",
+    )
+    over.add_argument("--state-path", type=Path, metavar="PATH")
+    over.add_argument("--attempt-cap", type=int, metavar="N", help="dev attempts per issue")
+    over.add_argument("--stale-minutes", type=int, metavar="MINUTES")
+    over.add_argument(
+        "--on-missing-origin-task",
+        choices=[ON_MISSING_WARN, ON_MISSING_SPAWN, ON_MISSING_SKIP],
+    )
+    over.add_argument("--on-missing-hub", choices=[HUB_SKIP, HUB_ADD])
+
+    dry = over.add_mutually_exclusive_group()
+    dry.add_argument(
+        "--dry-run",
+        dest="dry_run",
+        action="store_true",
+        default=None,
+        help="decide and log, but never spawn a session or touch GitHub state",
+    )
+    dry.add_argument(
+        "--no-dry-run",
+        dest="dry_run",
+        action="store_false",
+        help="act for real even if the config sets dry_run",
+    )
+    return p
+
+
+def overrides_from(args: argparse.Namespace) -> dict:
+    """CLI values, with None meaning 'not specified' so the config file shows
+    through. `repos`/`reviewers` become tuples so they match the file form."""
+    return {
+        "repos": tuple(args.repos) if args.repos else None,
+        "poll_interval": args.poll_interval,
+        "label": args.label,
+        "hub_template": args.hub_template,
+        "agent_profile": args.agent_profile,
+        "developer_login": args.developer_login,
+        "reviewers": tuple(args.reviewers) if args.reviewers else None,
+        "state_path": args.state_path,
+        "attempt_cap": args.attempt_cap,
+        "stale_minutes": args.stale_minutes,
+        "on_missing_origin_task": args.on_missing_origin_task,
+        "on_missing_hub": args.on_missing_hub,
+        "dry_run": args.dry_run,
+    }
+
+
+def resolve_config(args: argparse.Namespace) -> Config:
+    workspace_root = args.workspace_root or Path.cwd()
+    path = resolve_config_path(args.config_path, workspace_root)
+
+    file_data = load_config_file(path) if path else {}
+    log.info("config: %s", path or "none found — defaults + CLI arguments only")
+
+    config = Config.build(workspace_root, file_data, overrides_from(args))
+    return dataclasses.replace(
+        config,
+        reviewers=resolve_reviewers(config.reviewers, config.manifest_path),
+    )
+
+
+def log_effective_config(config: Config, login: str) -> None:
+    """The resolved settings, defaults and all. INFO carries the decisions an
+    operator needs; -v (DEBUG) shows the full surface."""
+    log.info("developing as GitHub user %s (from the gh token)", login)
+    log.info(
+        "watching %s for label %r",
+        ", ".join(config.repos) if config.repos
+        else "NO repos (empty allowlist — set `repos` or pass --repo)",
+        config.label,
+    )
+    log.info("reviewers: %s", ", ".join(config.reviewers) or "none")
+    log.info(
+        "poll every %ss; dry_run=%s; attempt_cap=%s; stale after %s min",
+        config.poll_interval, config.dry_run, config.attempt_cap, config.stale_minutes,
+    )
+    log.debug("hub_template: %s", config.hub_template)
+    log.debug("agent_profile: %s", config.agent_profile)
+    log.debug("developer_login: %s", config.developer_login or f"{login} (auto)")
+    log.debug("state_db: %s", config.state_db)
+    log.debug("on_missing_origin_task: %s", config.on_missing_origin_task)
+    log.debug("on_missing_hub: %s", config.on_missing_hub)
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    try:
+        config = resolve_config(args)
+        log.info("workspace: %s", config.workspace_root)
+
+        watcher = DevWatcher(config)
+        for warning in watcher.preflight():
+            log.warning(warning)
+        log_effective_config(config, watcher.github.login)
+
+        if args.once:
+            watcher.poll_once()
+        else:
+            watcher.run_forever()
+    except IdentityMismatch as exc:
+        print(f"identity error: {exc}", file=sys.stderr)
+        return 2
+    except (FileNotFoundError, ValueError) as exc:
+        print(f"config error: {exc}", file=sys.stderr)
+        return 2
+    except RateLimited as exc:
+        # Only --once can get here: run_forever absorbs rate limits by
+        # backing off, but a single pass has no next pass to wait for.
+        print(f"rate limited: {exc}", file=sys.stderr)
+        return 1
+    except CommandError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

alissa/tools/github/devloop/alissa.py

@@ -0,0 +1,75 @@
+"""Alissa CLI access: enqueue the fresh developer session and probe the
+worker. The developer's Alissa task is created by the session itself (as a
+downstream of the origin task), so unlike reviewloop there is no task lookup
+here -- the daemon's only Alissa surfaces are the tmux queue and the worker."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from .proc import CommandError, run
+
+log = logging.getLogger(__name__)
+
+
+class Alissa:
+    def enqueue_developer(
+        self,
+        *,
+        session: str,
+        directive: str,
+        cwd: Path,
+        agent: str,
+        dry_run: bool = False,
+    ) -> None:
+        argv = [
+            "alissa",
+            "tmux",
+            "queue",
+            "add",
+            session,
+            "--agent",
+            agent,
+            "--cwd",
+            str(cwd),
+            directive,
+        ]
+
+        if dry_run:
+            log.info("[dry-run] would enqueue: %s", " ".join(argv[:-1]) + " <directive>")
+            return
+
+        run(argv, timeout=60)
+
+        # Developers are one-shot per attempt: a finished (or dead) session must
+        # never be respawned by the worker -- staleness handling re-enqueues as
+        # attempt k+1 with a fresh session name instead. Best-effort: an older
+        # CLI without `queue set` should not fail the enqueue.
+        try:
+            run(["alissa", "tmux", "queue", "set", session, "respawn", "off"],
+                timeout=30, check=False)
+        except CommandError:  # pragma: no cover - defence in depth
+            log.warning("could not set respawn off for %s", session)
+
+    def add_repo_to_workspace(
+        self, owner: str, repo: str, workspace_root: Path, *, dry_run: bool = False
+    ) -> None:
+        """Hub-ify a repo into the workspace (bare clone + main/ worktree) and
+        record it in alissa-workspace.yaml. Idempotent per the CLI's contract."""
+        argv = ["alissa", "code", "workspace", "add", f"{owner}/{repo}"]
+        if dry_run:
+            log.info("[dry-run] would run: %s (cwd=%s)", " ".join(argv), workspace_root)
+            return
+
+        log.info("hub-ifying %s/%s into %s", owner, repo, workspace_root)
+        # Cloning a repo can be slow; the poll loop tolerates a long pass.
+        run(argv, timeout=600, cwd=workspace_root)
+
+    def worker_running(self) -> bool:
+        """The queue only drains while `alissa worker` reconciles it."""
+        try:
+            out = run(["alissa", "worker", "status"], timeout=30, check=False)
+        except CommandError:
+            return False
+        return "not running" not in out.lower() and "no worker" not in out.lower()

alissa/tools/github/devloop/config.py

@@ -0,0 +1,359 @@
+"""Daemon configuration.
+
+Settings come from three layers, later winning over earlier:
+
+1. the defaults on `Config`
+2. a JSON config file (see `resolve_config_path`)
+3. CLI arguments
+
+`workspace_root` is deliberately **not** a config key — it is a property of the
+running process, not of the settings. That lets one config file drive several
+daemons over different workspaces on the same machine, each pointed with
+`--workspace-root` and narrowed with `--repo`.
+
+Reviewers ride one extra rail on top of the three layers, highest first:
+the `ALISSA_DEV_REVIEWERS` env var (authoritative when set) > `--reviewer`
+flags > the config `reviewers` key > the workspace manifest's `reviewers:`
+list (see `resolve_reviewers`).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Mapping
+
+# What to do when a labeled issue has no matching Alissa origin task (the
+# label may have been applied by hand, outside the Alissa task flow).
+ON_MISSING_WARN = "warn_and_spawn"  # spawn, but log loudly
+ON_MISSING_SPAWN = "spawn_anyway"  # spawn quietly, the issue carries the spec
+ON_MISSING_SKIP = "skip"  # ignore the issue until an origin task appears
+
+_MISSING_MODES = {ON_MISSING_WARN, ON_MISSING_SPAWN, ON_MISSING_SKIP}
+
+# What to do when a labeled issue lands in a repo that has no worktree hub yet.
+HUB_SKIP = "skip"
+HUB_ADD = "add"  # `alissa code workspace add <org>/<repo>`
+
+_HUB_MODES = {HUB_SKIP, HUB_ADD}
+
+CONFIG_FILENAME = "devloop.config.json"
+
+# Comma-separated reviewer logins; authoritative when set, even if empty.
+ENV_REVIEWERS = "ALISSA_DEV_REVIEWERS"
+
+# Keys accepted in the config file. workspace_root is excluded on purpose.
+CONFIG_KEYS = (
+    "hub_template",
+    "poll_interval",
+    "label",
+    "repos",
+    "agent_profile",
+    "developer_login",
+    "reviewers",
+    "state_path",
+    "attempt_cap",
+    "stale_minutes",
+    "on_missing_origin_task",
+    "on_missing_hub",
+    "dry_run",
+)
+
+MIN_POLL_INTERVAL = 10  # the search API allows 30 req/min
+
+
+def default_state_path(workspace_root: Path) -> Path:
+    return Path(workspace_root) / ".devloop" / "state.db"
+
+
+def _string_list(value: Any, key: str) -> tuple[str, ...]:
+    """Coerce a config list, rejecting the scalar-for-list mistake loudly.
+
+    A bare JSON string would otherwise be exploded into characters by
+    `tuple(...)` — turning `"repos": "acme/widgets"` into a bogus 12-entry
+    allowlist that watches nothing yet still satisfies the `on_missing_hub`
+    guard's non-empty check. Fail at load time instead.
+    """
+    if isinstance(value, str):
+        raise ValueError(
+            f"{key} must be a list of strings, got a string: {value!r}. "
+            f"Use [{value!r}]."
+        )
+    if not isinstance(value, (list, tuple)):
+        raise ValueError(
+            f"{key} must be a list of strings, got {type(value).__name__}"
+        )
+    for item in value:
+        if not isinstance(item, str):
+            raise ValueError(
+                f"{key} must be a list of strings, got a "
+                f"{type(item).__name__} element: {item!r}"
+            )
+    return tuple(value)
+
+
+@dataclass(frozen=True)
+class Config:
+    # A property of the process, supplied by --workspace-root (default: cwd).
+    workspace_root: Path
+
+    # The hub ROOT — unlike reviewloop's `{root}/{repo}/main` there is no
+    # trailing checkout: dev sessions create their own task worktree under it.
+    hub_template: str = "{root}/{repo}"
+    poll_interval: int = 60
+    label: str = "alissa:develop"
+
+    # Allowlist of owner/repo. Empty means NOTHING is watched — a daemon that
+    # writes code only ever works an explicit allowlist. (This deliberately
+    # differs from reviewloop, where empty means "every repo".)
+    repos: tuple[str, ...] = ()
+
+    agent_profile: str = "claude"
+    developer_login: str | None = None  # None -> resolve once via `gh api user`
+
+    # Post-merge reviewers as they appear in the winning layer -- read
+    # `resolve_reviewers` for the manifest/env fallbacks around this field.
+    reviewers: tuple[str, ...] = ()
+
+    # None means "derive from the workspace" -- read `state_db` for the
+    # resolved location, never this field.
+    state_path: Path | None = None
+
+    attempt_cap: int = 2
+    stale_minutes: int = 120
+
+    on_missing_origin_task: str = ON_MISSING_WARN
+    on_missing_hub: str = HUB_SKIP
+    dry_run: bool = False
+
+    # Derived at build time: `repos` casefolded for matching. GitHub names are
+    # case-insensitive, but `repos` keeps the operator's casing for logs/repr.
+    _repo_match: frozenset[str] = field(
+        default=frozenset(), init=False, repr=False, compare=False
+    )
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "workspace_root", Path(self.workspace_root).expanduser().resolve()
+        )
+        object.__setattr__(
+            self, "_repo_match", frozenset(r.casefold() for r in self.repos)
+        )
+
+    @property
+    def state_db(self) -> Path:
+        """Where the attempt ledger lives. Defaults inside the workspace so two
+        daemons watching different workspaces never share one."""
+        if self.state_path is None:
+            return default_state_path(self.workspace_root)
+        return Path(self.state_path).expanduser()
+
+    @property
+    def manifest_path(self) -> Path:
+        return self.workspace_root / "alissa-workspace.yaml"
+
+    def hub_for(self, owner: str, repo: str) -> Path:
+        return Path(
+            self.hub_template.format(
+                root=str(self.workspace_root), owner=owner, repo=repo
+            )
+        ).expanduser()
+
+    def watches(self, full_name: str) -> bool:
+        """Empty allowlist = watch nothing (NOT everything — the daemon spawns
+        sessions that write and push code, so the blast radius is opt-in).
+        Matching is case-insensitive, like GitHub owner/repo names."""
+        return full_name.casefold() in self._repo_match
+
+    @classmethod
+    def build(
+        cls,
+        workspace_root: Path,
+        file_data: Mapping[str, Any] | None = None,
+        overrides: Mapping[str, Any] | None = None,
+    ) -> "Config":
+        """Merge the layers and validate. `overrides` entries that are None mean
+        "not specified on the CLI" and fall through to the file / defaults."""
+        raw: dict[str, Any] = dict(file_data or {})
+
+        if "workspace_root" in raw:
+            raise ValueError(
+                "workspace_root is not a config key — it is a property of the "
+                "running process. Pass --workspace-root (or run the daemon from "
+                "the workspace), and remove it from the config file."
+            )
+
+        # Allow "_"-prefixed keys as inline comments, since JSON has none.
+        unknown = {k for k in set(raw) - set(CONFIG_KEYS) if not k.startswith("_")}
+        if unknown:
+            raise ValueError(
+                f"unknown config key(s): {', '.join(sorted(unknown))}. "
+                f"Valid keys: {', '.join(CONFIG_KEYS)}"
+            )
+
+        for key, value in (overrides or {}).items():
+            if value is not None:
+                raw[key] = value
+
+        mode = raw.get("on_missing_origin_task", cls.on_missing_origin_task)
+        if mode not in _MISSING_MODES:
+            raise ValueError(
+                f"on_missing_origin_task must be one of {sorted(_MISSING_MODES)}, got {mode!r}"
+            )
+
+        hub_mode = raw.get("on_missing_hub", cls.on_missing_hub)
+        if hub_mode not in _HUB_MODES:
+            raise ValueError(
+                f"on_missing_hub must be one of {sorted(_HUB_MODES)}, got {hub_mode!r}"
+            )
+
+        repos = _string_list(raw.get("repos", cls.repos), "repos")
+        if hub_mode == HUB_ADD and not repos:
+            # Anyone who can label an issue could otherwise cause an arbitrary
+            # repo to be cloned onto this machine and opened as an agent's cwd.
+            raise ValueError(
+                "on_missing_hub='add' requires a non-empty repos allowlist "
+                "(config `repos`, or one or more --repo flags) — auto-cloning "
+                "whatever repo grows a labeled issue is unbounded"
+            )
+
+        cap = int(raw.get("attempt_cap", cls.attempt_cap))
+        if cap < 1:
+            raise ValueError(f"attempt_cap must be >= 1, got {cap}")
+
+        stale = int(raw.get("stale_minutes", cls.stale_minutes))
+        if stale < 1:
+            raise ValueError(f"stale_minutes must be >= 1, got {stale}")
+
+        interval = int(raw.get("poll_interval", cls.poll_interval))
+        if interval < MIN_POLL_INTERVAL:
+            raise ValueError(
+                f"poll_interval must be >= {MIN_POLL_INTERVAL} seconds, got {interval}"
+            )
+
+        state_path = raw.get("state_path")
+        return cls(
+            workspace_root=Path(workspace_root),
+            hub_template=raw.get("hub_template", cls.hub_template),
+            poll_interval=interval,
+            label=raw.get("label", cls.label),
+            repos=repos,
+            agent_profile=raw.get("agent_profile", cls.agent_profile),
+            developer_login=raw.get("developer_login"),
+            reviewers=_string_list(raw.get("reviewers", cls.reviewers), "reviewers"),
+            state_path=Path(state_path).expanduser() if state_path else None,
+            attempt_cap=cap,
+            stale_minutes=stale,
+            on_missing_origin_task=mode,
+            on_missing_hub=hub_mode,
+            dry_run=bool(raw.get("dry_run", cls.dry_run)),
+        )
+
+
+def load_config_file(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(Path(path).expanduser().read_text())
+    except json.JSONDecodeError as exc:
+        # json.loads has no filename to report, and discovery is implicit
+        # across two locations — always name the file that failed to parse.
+        raise ValueError(f"{path}: invalid JSON — {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"{path}: expected a JSON object, got {type(data).__name__}")
+    return data
+
+
+def resolve_config_path(
+    explicit: Path | None, workspace_root: Path, cwd: Path | None = None
+) -> Path | None:
+    """Find the config file: explicit path, then cwd, then the workspace root.
+
+    Returns None when no config file exists — CLI arguments and defaults alone
+    are a valid way to run. An explicit path that does not exist is an error.
+    """
+    if explicit is not None:
+        path = Path(explicit).expanduser()
+        if not path.is_file():
+            raise FileNotFoundError(f"config file not found: {path}")
+        return path
+
+    cwd = Path.cwd() if cwd is None else Path(cwd)
+    for candidate in (cwd / CONFIG_FILENAME, Path(workspace_root) / CONFIG_FILENAME):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _clean_item(item: str) -> str:
+    return item.strip().strip("'\"").strip()
+
+
+def manifest_reviewers(manifest_path: Path) -> tuple[str, ...]:
+    """Extract the top-level `reviewers:` list from alissa-workspace.yaml.
+
+    Deliberately a minimal line-based scan, not a YAML parser — the
+    distribution stays stdlib-only. Handles the inline form
+    (`reviewers: []`, `reviewers: [a, b]`) and the block form
+    (`reviewers:` followed by `- a` lines, indented or at column 0 — both
+    are valid YAML). A missing manifest, or one without the key, yields no
+    reviewers.
+    """
+    try:
+        lines = Path(manifest_path).read_text().splitlines()
+    except OSError:
+        return ()
+
+    for index, line in enumerate(lines):
+        if line[:1] in (" ", "\t"):
+            continue  # only the top-level key counts
+        stripped = line.split("#", 1)[0].rstrip()
+        if not stripped.startswith("reviewers:"):
+            continue
+
+        rest = stripped[len("reviewers:"):].strip()
+        if rest.startswith("[") and rest.endswith("]"):
+            inner = rest[1:-1]
+            return tuple(
+                cleaned for part in inner.split(",")
+                if (cleaned := _clean_item(part))
+            )
+        if rest:
+            # A scalar (`reviewers: alice`) — treat it as a one-item list.
+            cleaned = _clean_item(rest)
+            return (cleaned,) if cleaned else ()
+
+        items: list[str] = []
+        for follow in lines[index + 1:]:
+            body = follow.split("#", 1)[0]
+            if not body.strip():
+                continue  # blank / comment-only lines do not end the block
+            if not body.lstrip().startswith("-"):
+                break  # a new top-level `key:` (or any non-item) ends the block
+            items.append(_clean_item(body.strip()[1:]))
+        return tuple(item for item in items if item)
+
+    return ()
+
+
+def resolve_reviewers(
+    merged: tuple[str, ...],
+    manifest_path: Path,
+    environ: Mapping[str, str] | None = None,
+) -> tuple[str, ...]:
+    """Final reviewers, applying the rails around the three config layers.
+
+    `merged` is the reviewers value after the usual defaults→file→CLI merge
+    (so `--reviewer` flags have already replaced the config key). Highest
+    precedence first: the ALISSA_DEV_REVIEWERS env var — authoritative
+    whenever it is set, even set-but-empty (which means "no reviewers") —
+    then the merged value, then the workspace manifest's `reviewers:` list.
+    """
+    env = (os.environ if environ is None else environ).get(ENV_REVIEWERS)
+    if env is not None:
+        return tuple(
+            cleaned for part in env.split(",") if (cleaned := _clean_item(part))
+        )
+    if merged:
+        return merged
+    return manifest_reviewers(manifest_path)