bmsdna-devtools 0.6.0__tar.gz → 0.8.0__tar.gz

bmsdna_devtools-0.8.0/.github/workflows/auto-release.yml

@@ -0,0 +1,83 @@
+# Auto-tags, cuts a GitHub Release, and dispatches a PyPI publish whenever
+# pyproject.toml's version changes on main and the Python Test workflow has
+# passed for that commit. No manual "cut a release" step needed.
+#
+# Two GitHub Actions quirks shaped this design -- both hit and confirmed the
+# hard way, so read before "simplifying" this:
+#
+# 1. GitHub Actions doesn't fire other workflows' triggers (release:
+#    published included) for events performed with the automatic
+#    GITHUB_TOKEN, to prevent recursive runs. So creating the release here
+#    would NOT, on its own, trigger python-publish.yml's `release: published`
+#    listener. workflow_dispatch is the documented exception to that rule --
+#    an API-triggered workflow_dispatch DOES start a new run even when
+#    triggered by GITHUB_TOKEN -- so this dispatches python-publish.yml
+#    directly instead of relying on the release event to cascade.
+#
+# 2. The obvious alternative -- calling python-publish.yml's job directly via
+#    workflow_call instead of dispatching it as a separate run -- avoids (1)
+#    entirely, but breaks PyPI's OIDC trusted publishing: PyPI explicitly
+#    does not support trusted publishing from reusable/called workflows (the
+#    token's claims show a "reusable workflow" parent chain that PyPI's
+#    trusted-publisher matching rejects). So python-publish.yml must stay a
+#    plain, directly-triggered top-level workflow -- no workflow_call trigger
+#    on it, and nothing here should invoke it as `uses:`.
+
+name: Auto Release
+
+on:
+  workflow_run:
+    workflows: ["Python Test"]
+    types: [completed]
+
+permissions:
+  contents: read
+
+jobs:
+  release:
+    if: >
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push' &&
+      github.event.workflow_run.head_branch == 'main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      actions: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Read version from pyproject.toml
+        id: version
+        run: |
+          version=$(grep -m1 '^version = ' pyproject.toml | sed -E 's/version = "([^"]+)"/\1/')
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Skip if this version is already on PyPI
+        id: check
+        run: |
+          version="${{ steps.version.outputs.version }}"
+          if curl -fsS https://pypi.org/pypi/bmsdna-devtools/json | jq -e --arg v "$version" '.releases[$v] != null' >/dev/null; then
+            echo "published=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "published=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Create tag and GitHub release, if missing
+        if: steps.check.outputs.published == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if ! gh release view "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            gh release create "v${{ steps.version.outputs.version }}" \
+              --title "v${{ steps.version.outputs.version }}" \
+              --target "${{ github.event.workflow_run.head_sha }}" \
+              --generate-notes
+          fi
+
+      - name: Dispatch PyPI publish
+        if: steps.check.outputs.published == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh workflow run python-publish.yml --ref main

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.6.0
+Version: 0.8.0
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.32.0
@@ -78,6 +78,27 @@ title/body from commit info so it never blocks on an interactive prompt).
 Extra arguments pass through either way, e.g.
 `bdt pr create --target main -- --title "..."`.
 
+`--label` (repeatable) applies labels to the PR on either host: on GitHub
+these map to `gh pr create --label`, so the label must already exist on the
+repo (`gh label create`); on Azure DevOps they map to `az repos pr create
+--labels`, which are freeform and get created on the fly. A successful
+create prints the PR's web/GUI link (not just the REST API URL Azure DevOps'
+`az` output otherwise gives you).
+
+`[tool.bdt.pr.required_labels]` in pyproject.toml can require at least one
+label from each named group before the PR is created — checked locally
+(no `gh`/`az` call happens if a group isn't satisfied):
+
+```toml
+[tool.bdt.pr.required_labels]
+type = ["bug", "feature", "chore"]
+risk = ["breaking", "non-breaking"]
+```
+
+With the above, `bdt pr create --label feature --label breaking` passes,
+but `bdt pr create --label feature` fails with a message naming the unmet
+group (`risk`) and its allowed choices.
+
 If `--target` has a build policy configured (an Azure DevOps Build policy,
 or a GitHub branch protection rule requiring status checks), a successful
 create prints a reminder to run `bdt pr status` afterward to check whether
@@ -222,3 +243,29 @@ slot = "test"
 bdt logs fetch --env prod
 bdt logs fetch --env prod --out logs/ --keep-archive
 ```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` as part of your PR, same as any other
+change. Once that PR merges to `main` and the `Python Test` workflow passes
+for that commit, `.github/workflows/auto-release.yml` automatically tags it
+`vX.Y.Z`, cuts a GitHub Release (skipping if that version was already
+released, e.g. a merge that didn't touch the version), and dispatches
+`python-publish.yml` to publish it to PyPI — no manual release step, and no
+extra secret to configure. Two non-obvious GitHub Actions quirks shaped
+this (see the comments at the top of `auto-release.yml` for the full
+reasoning, since both were hit and confirmed the hard way):
+
+- A release created with the default `GITHUB_TOKEN` does **not** trigger
+  other workflows' `release: published` listeners (an anti-recursion
+  safeguard) — `workflow_dispatch` is the documented exception, so
+  `auto-release.yml` dispatches `python-publish.yml` directly (`gh workflow
+  run`) instead of relying on the release to cascade into it.
+- `python-publish.yml` deliberately stays a plain, directly-triggered
+  top-level workflow rather than something `auto-release.yml` calls via
+  `workflow_call`: PyPI's OIDC trusted publishing does not support
+  reusable/called workflows and silently rejects the token in that shape.
+
+`workflow_dispatch` (or an actual GitHub UI release) on `python-publish.yml`
+still works as a manual fallback if you ever need to re-publish a version
+without going through `auto-release.yml`.

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/README.md

@@ -68,6 +68,27 @@ title/body from commit info so it never blocks on an interactive prompt).
 Extra arguments pass through either way, e.g.
 `bdt pr create --target main -- --title "..."`.
 
+`--label` (repeatable) applies labels to the PR on either host: on GitHub
+these map to `gh pr create --label`, so the label must already exist on the
+repo (`gh label create`); on Azure DevOps they map to `az repos pr create
+--labels`, which are freeform and get created on the fly. A successful
+create prints the PR's web/GUI link (not just the REST API URL Azure DevOps'
+`az` output otherwise gives you).
+
+`[tool.bdt.pr.required_labels]` in pyproject.toml can require at least one
+label from each named group before the PR is created — checked locally
+(no `gh`/`az` call happens if a group isn't satisfied):
+
+```toml
+[tool.bdt.pr.required_labels]
+type = ["bug", "feature", "chore"]
+risk = ["breaking", "non-breaking"]
+```
+
+With the above, `bdt pr create --label feature --label breaking` passes,
+but `bdt pr create --label feature` fails with a message naming the unmet
+group (`risk`) and its allowed choices.
+
 If `--target` has a build policy configured (an Azure DevOps Build policy,
 or a GitHub branch protection rule requiring status checks), a successful
 create prints a reminder to run `bdt pr status` afterward to check whether
@@ -212,3 +233,29 @@ slot = "test"
 bdt logs fetch --env prod
 bdt logs fetch --env prod --out logs/ --keep-archive
 ```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` as part of your PR, same as any other
+change. Once that PR merges to `main` and the `Python Test` workflow passes
+for that commit, `.github/workflows/auto-release.yml` automatically tags it
+`vX.Y.Z`, cuts a GitHub Release (skipping if that version was already
+released, e.g. a merge that didn't touch the version), and dispatches
+`python-publish.yml` to publish it to PyPI — no manual release step, and no
+extra secret to configure. Two non-obvious GitHub Actions quirks shaped
+this (see the comments at the top of `auto-release.yml` for the full
+reasoning, since both were hit and confirmed the hard way):
+
+- A release created with the default `GITHUB_TOKEN` does **not** trigger
+  other workflows' `release: published` listeners (an anti-recursion
+  safeguard) — `workflow_dispatch` is the documented exception, so
+  `auto-release.yml` dispatches `python-publish.yml` directly (`gh workflow
+  run`) instead of relying on the release to cascade into it.
+- `python-publish.yml` deliberately stays a plain, directly-triggered
+  top-level workflow rather than something `auto-release.yml` calls via
+  `workflow_call`: PyPI's OIDC trusted publishing does not support
+  reusable/called workflows and silently rejects the token in that shape.
+
+`workflow_dispatch` (or an actual GitHub UI release) on `python-publish.yml`
+still works as a manual fallback if you ever need to re-publish a version
+without going through `auto-release.yml`.

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/bmsdna/devtools/ado_issue.py

@@ -264,6 +264,106 @@ def html_url(work_item: dict) -> str | None:
     return work_item.get("_links", {}).get("html", {}).get("href")
 
 
+def edit_url(remote: AdoRemote, work_item_id: int) -> str:
+    return f"{_base_url(remote)}/_workitems/edit/{work_item_id}"
+
+
+def _escape_wiql_string(value: str) -> str:
+    return value.replace("'", "''")
+
+
+# The Completed/Removed-category state names across Azure DevOps's built-in process templates:
+# Agile and CMMI use 'Closed' for Completed, Scrum and Basic use 'Done'; all four use 'Removed'.
+# There's no single field/value that means "terminal" independent of process template, so this
+# union is the closest thing to a default that works out of the box on any of them.
+_TERMINAL_STATES = ("Closed", "Done", "Removed")
+
+
+def build_search_wiql(
+    keywords: list[str],
+    since: str | None = None,
+    area_path: str | None = None,
+    state: str = "open",
+) -> str:
+    """WIQL for work items whose Title or Description contains every given keyword (ANDed),
+    optionally restricted to items changed on/after `since` (an ISO 'YYYY-MM-DD' date) and/or
+    scoped to a board's Area Path subtree, most recently changed first. `keywords` may be empty,
+    to list work items without a text filter.
+
+    `since` is rendered as a UTC ISO 8601 literal (`'YYYY-MM-DDT00:00:00Z'`) — the one
+    DateTime format WIQL accepts regardless of the querying account's locale/date-pattern
+    preference (a bare `'YYYY-MM-DD'` is parsed using that locale's date pattern instead).
+
+    `state` is `"open"` (default, excludes `_TERMINAL_STATES`), `"closed"` (only those), or
+    `"all"` (no state filter). Azure DevOps state names are process-template-specific — Agile and
+    CMMI use 'Closed' for their Completed-category state, Scrum and Basic use 'Done' — so
+    `_TERMINAL_STATES` is the union across the built-in templates, not a per-project source of
+    truth (a custom process with its own state names won't be filtered correctly).
+    """
+    clauses = [
+        f"([System.Title] Contains Words '{_escape_wiql_string(k)}' OR [System.Description] Contains Words '{_escape_wiql_string(k)}')"
+        for k in keywords
+    ]
+    if since:
+        clauses.append(f"[System.ChangedDate] >= '{since}T00:00:00Z'")
+    if area_path:
+        clauses.append(f"[System.AreaPath] UNDER '{_escape_wiql_string(area_path)}'")
+    if state == "open":
+        clauses.append(" AND ".join(f"[System.State] <> '{s}'" for s in _TERMINAL_STATES))
+    elif state == "closed":
+        clauses.append("(" + " OR ".join(f"[System.State] = '{s}'" for s in _TERMINAL_STATES) + ")")
+    where = " AND ".join(["[System.TeamProject] = @project", *clauses])
+    return f"SELECT [System.Id] FROM WorkItems WHERE {where} ORDER BY [System.ChangedDate] DESC"
+
+
+def run_wiql(session: requests.Session, remote: AdoRemote, wiql: str, top: int) -> list[int]:
+    r = session.post(
+        f"{_base_url(remote)}/_apis/wit/wiql",
+        params={"api-version": "7.1", "$top": top},
+        json={"query": wiql},
+    )
+    r.raise_for_status()
+    return [wi["id"] for wi in r.json()["workItems"]]
+
+
+def get_work_items(session: requests.Session, remote: AdoRemote, ids: list[int]) -> list[dict]:
+    """Batch-fetch Title/State for a set of work item ids. WIQL only returns ids, not field values."""
+    if not ids:
+        return []
+    r = session.get(
+        f"{_base_url(remote)}/_apis/wit/workitems",
+        params={"ids": ",".join(map(str, ids)), "fields": "System.Title,System.State", "api-version": "7.1"},
+    )
+    r.raise_for_status()
+    return r.json()["value"]
+
+
+def search(
+    session: requests.Session,
+    remote: AdoRemote,
+    keywords: list[str],
+    since: str | None = None,
+    board: str | None = None,
+    top: int = 10,
+    state: str = "open",
+) -> list[dict]:
+    """Search (or, with no keywords, just list) work items by keywords (ANDed, matched against
+    Title or Description) and state, most recently changed first. `board` is an Azure Boards team
+    name (like `create`'s `--board`) — resolved to its Area Path so results are scoped to that
+    team's subtree instead of the whole project.
+    """
+    area_path = get_team_area_path(session, remote, board) if board else None
+    ids = run_wiql(session, remote, build_search_wiql(keywords, since, area_path, state), top)
+    items = get_work_items(session, remote, ids)
+    for item in items:
+        fields = item["fields"]
+        print(f"#{item['id']} [{fields['System.State']}] {fields['System.Title']}")
+        print(edit_url(remote, item["id"]))
+    if not items:
+        print("No matching work items found.")
+    return items
+
+
 def create(
     session: requests.Session,
     remote: AdoRemote,

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/bmsdna/devtools/cli.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import json
 import subprocess
 import sys
 from collections.abc import Callable
+from datetime import datetime, timedelta, timezone
 from importlib.metadata import version as _pkg_version
 from pathlib import Path
 
@@ -13,7 +15,7 @@ from . import ado_issue, app_service_logs, commit as commit_mod
 from . import env_config
 from . import gh_issue, gh_pr
 from . import logs as logs_mod
-from . import pr_build, worktree as worktree_mod
+from . import pr_build, pr_labels, worktree as worktree_mod
 from .ado_auth import auth_header
 from .cli_tools import require_az, require_gh
 from .gitrepo import AdoRemote, GitHubRemote, current_branch, current_remote
@@ -90,6 +92,14 @@ def _attach_screenshots(attach: Callable[[], None]) -> None:
 def pr_create(
     target: str = typer.Option("main", "--target", help="Target branch (e.g. main, test)"),
     draft: bool = typer.Option(False, "--draft", help="Create the PR as a draft (not ready for review)"),
+    label: list[str] = typer.Option(
+        [],
+        "--label",
+        help="Label to apply to the PR (repeatable). On GitHub the label must already exist on the repo "
+        "(`gh label create`); Azure DevOps PR labels are freeform and created on the fly. "
+        r"[tool.bdt.pr.required_labels] in pyproject.toml can require at least one label from each "
+        "named group before the PR is created.",
+    ),
     screenshot: list[str] = typer.Option(
         [], "--screenshot", help="Path to an image to attach to the PR description (repeatable)"
     ),
@@ -106,11 +116,16 @@ def pr_create(
         if not Path(path).is_file():
             raise typer.BadParameter(f"Screenshot not found: {path}", param_hint="--screenshot")
 
+    missing_groups = pr_labels.missing_label_groups(pr_labels.required_label_groups(), label)
+    if missing_groups:
+        raise typer.BadParameter(pr_labels.format_missing_groups_error(missing_groups), param_hint="--label")
+
     remote = current_remote()
     source_branch = current_branch()
+    pr_url: str | None = None
     if isinstance(remote, GitHubRemote):
         gh = require_gh()
-        returncode = gh_pr.create(gh, target, args or [], draft=draft)
+        returncode, pr_url = gh_pr.create(gh, target, args or [], draft=draft, labels=label)
         build_policy = gh_pr.has_build_policy(gh, target)
         if returncode == 0 and screenshot:
             _attach_screenshots(lambda: gh_pr.add_screenshots(gh, remote.owner, remote.repo, source_branch, screenshot))
@@ -125,10 +140,33 @@ def pr_create(
             "--target-branch", target,
             "--source-branch", source_branch,
             "--auto-complete", "false",
+            "--output", "json",
             *(["--draft", "true"] if draft else []),
+            *(["--labels", *label] if label else []),
             *(args or []),
         ]
-        returncode = subprocess.run(cmd).returncode
+        r = subprocess.run(cmd, capture_output=True, encoding="utf-8")
+        returncode = r.returncode
+        if isinstance(r.stderr, str) and r.stderr.strip():
+            print(r.stderr.strip(), file=sys.stderr)
+
+        pr_json = None
+        if returncode == 0 and isinstance(r.stdout, str):
+            try:
+                pr_json = json.loads(r.stdout)
+            except json.JSONDecodeError:
+                pr_json = None
+
+        if pr_json is not None:
+            # Concise summary instead of the raw `az` JSON blob — the web
+            # link printed below is the part a human actually needs.
+            print(f"PR #{pr_json.get('pullRequestId', '?')}: {pr_json.get('title', '?')}")
+            try:
+                pr_url = pr_build.pr_web_url(remote, pr_json["pullRequestId"])
+            except (KeyError, TypeError):
+                pr_url = None
+        elif isinstance(r.stdout, str) and r.stdout.strip():
+            print(r.stdout.rstrip())
         session = requests.Session()
         session.headers.update(auth_header(pat))
         build_policy = pr_build.has_build_policy(session, remote, target)
@@ -140,6 +178,9 @@ def pr_create(
             _attach_screenshots(_add)
         publish_hint = "`az repos pr update --id <PR-ID> --draft false`"
 
+    if returncode == 0 and pr_url:
+        print(f"\n{pr_url}")
+
     if returncode == 0 and draft:
         print(f"\nCreated as a draft PR. Run `bdt pr publish` (or {publish_hint}) to mark it ready for review.")
 
@@ -285,6 +326,46 @@ def issue_create(
         ado_issue.create(session, remote, type_, title, description, resolved_board, tag, screenshot)
 
 
+@issue_app.command("search")
+def issue_search(
+    keywords: list[str] = typer.Argument(
+        None, help="Keywords to search for (ANDed together); omit to just list issues/work items"
+    ),
+    since_days: int = typer.Option(
+        30, "--since-days", help="Only include issues/work items updated within this many days (0 = no date filter)"
+    ),
+    state: str = typer.Option("open", "--state", help="Filter by state: 'open', 'closed', or 'all'"),
+    board: str | None = typer.Option(
+        None,
+        "--board",
+        help="Scope the search to this Azure Boards team's Area Path subtree (Azure DevOps only; "
+        r"falls back to \[tool.bdt.ado].board in pyproject.toml, same as `issue create`)",
+    ),
+    limit: int = typer.Option(10, "--limit", help="Max results to return"),
+    pat: str | None = typer.Option(
+        None,
+        "--pat",
+        envvar=["AZURE_DEVOPS_EXT_PAT", "AZURE_DEVOPS_PAT"],
+        help="Azure DevOps PAT (else falls back to `az` login)",
+    ),
+) -> None:
+    """Search (or, with no keywords, just list) issues / work items, defaulting to open issues
+    from the last 30 days (Azure DevOps or GitHub, auto-detected).
+    """
+    if state not in ("open", "closed", "all"):
+        raise typer.BadParameter("Must be one of: open, closed, all", param_hint="--state")
+    since = (datetime.now(timezone.utc) - timedelta(days=since_days)).strftime("%Y-%m-%d") if since_days > 0 else None
+
+    remote = current_remote()
+    if isinstance(remote, GitHubRemote):
+        gh_issue.search(require_gh(), keywords or [], since, limit, state)
+    else:
+        session = requests.Session()
+        session.headers.update(auth_header(pat))
+        resolved_board = ado_issue.resolve_board(board)
+        ado_issue.search(session, remote, keywords or [], since=since, board=resolved_board, top=limit, state=state)
+
+
 @issue_app.command("update")
 def issue_update(
     number: int = typer.Argument(..., help="Issue number (GitHub) or work item ID (Azure DevOps)"),

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/bmsdna/devtools/gh_issue.py

@@ -18,6 +18,7 @@ hosts).
 
 from __future__ import annotations
 
+import json
 import re
 import subprocess
 import sys
@@ -81,6 +82,35 @@ def create(
         print(f"Attached {len(screenshot_paths)} screenshot(s) to issue #{number}")
 
 
+def build_search_query(keywords: list[str], since: str | None) -> str:
+    """The `gh issue list --search` query string: keywords ANDed together (GitHub search's
+    implicit default), optionally scoped to issues updated on/after `since` (an ISO
+    'YYYY-MM-DD' date) via the `updated:` qualifier. Always sorted `updated:desc` — GitHub's
+    default search order is text-relevance, not recency, which `search()`'s ordering relies on.
+    `keywords` may be empty, to list issues without a text filter.
+    """
+    parts = [*keywords, "sort:updated-desc"]
+    if since:
+        parts.append(f"updated:>={since}")
+    return " ".join(parts)
+
+
+def search(gh: str, keywords: list[str], since: str | None, limit: int, state: str = "open") -> list[dict]:
+    """Search (or, with no keywords, just list) issues by state, most recently updated first.
+
+    `state` is `gh issue list`'s own `open|closed|all` flag, not a search qualifier.
+    """
+    query = build_search_query(keywords, since)
+    out = _run_gh(gh, ["issue", "list", "--search", query, "--state", state, "--limit", str(limit), "--json", "number,title,url,state"])
+    items = json.loads(out) if out else []
+    for item in items:
+        print(f"#{item['number']} [{item['state']}] {item['title']}")
+        print(item["url"])
+    if not items:
+        print("No matching issues found.")
+    return items
+
+
 def update(
     gh: str,
     number: int,

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/bmsdna/devtools/gh_pr.py

@@ -140,15 +140,32 @@ def run(gh: str, wait: bool) -> None:
         return
 
 
-def create(gh: str, target: str, extra_args: list[str], draft: bool = False) -> int:
+def create(gh: str, target: str, extra_args: list[str], draft: bool = False, labels: list[str] | None = None) -> tuple[int, str | None]:
     """Create a GitHub PR from the current branch into `target`.
 
     --fill autofills title/body from commit info so this never blocks on an
     interactive prompt; pass --title/--body in extra_args to override (gh
     lets explicit values take precedence over --fill).
+
+    `-l/--label` labels must already exist on the repo (`gh label create`) —
+    unlike Azure DevOps PR labels, GitHub rejects a label name it doesn't
+    already know about.
+
+    Returns (returncode, web_url) — on success `gh pr create` prints the
+    PR's web URL as its only stdout line, which is what a human needs to
+    open it; on failure the url is `None` and the CLI's stderr is
+    surfaced to ours.
     """
-    cmd = [gh, "pr", "create", "--base", target, "--fill", *(["--draft"] if draft else []), *extra_args]
-    return subprocess.run(cmd).returncode
+    cmd = [gh, "pr", "create", "--base", target, "--fill", *(["--draft"] if draft else [])]
+    for label in labels or []:
+        cmd += ["--label", label]
+    cmd += extra_args
+    r = subprocess.run(cmd, capture_output=True, encoding="utf-8")
+    if r.stderr:
+        print(r.stderr.strip(), file=sys.stderr)
+    if r.returncode != 0:
+        return r.returncode, None
+    return r.returncode, r.stdout.strip() or None
 
 
 def publish(gh: str) -> None:

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/bmsdna/devtools/pr_build.py

@@ -30,6 +30,13 @@ def _base_url(remote: AdoRemote) -> str:
     return f"https://dev.azure.com/{remote.org}/{quote(remote.project, safe='')}"
 
 
+def pr_web_url(remote: AdoRemote, pr_id: int) -> str:
+    """The browsable web page for a PR, as opposed to its REST API URL (which is all the
+    `az repos pr create` JSON response otherwise gives you).
+    """
+    return f"{_base_url(remote)}/_git/{quote(remote.repo, safe='')}/pullrequest/{pr_id}"
+
+
 # PolicyType.id for the built-in "Build" policy (branch policy requiring a
 # build to pass) — same GUID across every ADO organization.
 BUILD_POLICY_TYPE_ID = "0609b952-1397-4640-95ec-e00a01b2c241"

bmsdna_devtools-0.8.0/bmsdna/devtools/pr_labels.py

@@ -0,0 +1,43 @@
+"""Required PR label groups, configured under `[tool.bdt.pr.required_labels]`
+in pyproject.toml:
+
+    [tool.bdt.pr.required_labels]
+    type = ["bug", "feature", "chore"]
+    risk = ["breaking", "non-breaking"]
+
+Each key names a group; its value is the labels that satisfy it. `bdt pr
+create` must be given at least one label from every configured group
+(checked locally, before talking to GitHub/Azure DevOps, so a PR missing a
+required label is never created in the first place). Applies identically on
+both hosts.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .bdt_config import load_bdt_table
+
+
+def required_label_groups(start: Path | None = None) -> dict[str, list[str]]:
+    """`[tool.bdt.pr.required_labels]` -> {group name: [allowed label, ...]}."""
+    raw = load_bdt_table("pr", start).get("required_labels", {})
+    if not isinstance(raw, dict):
+        return {}
+    return {name: choices for name, choices in raw.items() if isinstance(choices, list)}
+
+
+def missing_label_groups(groups: dict[str, list[str]], labels: list[str]) -> dict[str, list[str]]:
+    """The subset of `groups` for which none of `labels` is a member.
+
+    Matched case-insensitively — this is a local config check independent of
+    whatever casing rules GitHub/Azure DevOps apply to the label text that
+    actually gets sent through unchanged.
+    """
+    given = {label.lower() for label in labels}
+    return {name: choices for name, choices in groups.items() if given.isdisjoint(choice.lower() for choice in choices)}
+
+
+def format_missing_groups_error(missing: dict[str, list[str]]) -> str:
+    parts = [f"'{name}' (choose one of: {', '.join(choices)})" for name, choices in missing.items()]
+    return "Missing required PR label(s) for group " + "; group ".join(parts)

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["bmsdna"]
 
 [project]
 name = "bmsdna-devtools"
-version = "0.6.0"
+version = "0.8.0"
 description = "Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects"
 readme = "README.md"
 requires-python = ">=3.11"

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/tests/test_ado_issue.py

@@ -1,4 +1,13 @@
-from bmsdna.devtools.ado_issue import build_attach_ops, build_create_ops, build_update_ops, html_url, resolve_board
+from bmsdna.devtools.ado_issue import (
+    build_attach_ops,
+    build_create_ops,
+    build_search_wiql,
+    build_update_ops,
+    edit_url,
+    html_url,
+    resolve_board,
+)
+from bmsdna.devtools.gitrepo import AdoRemote
 
 
 def write_pyproject(tmp_path, body: str):
@@ -91,3 +100,66 @@ def test_html_url_present() -> None:
 
 def test_html_url_missing() -> None:
     assert html_url({}) is None
+
+
+def test_edit_url() -> None:
+    assert edit_url(AdoRemote(org="myorg", project="MyProj", repo="myrepo"), 42) == "https://dev.azure.com/myorg/MyProj/_workitems/edit/42"
+
+
+def test_build_search_wiql_keywords_only() -> None:
+    wiql = build_search_wiql(["auth"], state="all")
+    assert "[System.TeamProject] = @project" in wiql
+    assert "[System.Title] Contains Words 'auth'" in wiql
+    assert "[System.Description] Contains Words 'auth'" in wiql
+    assert "[System.ChangedDate] >=" not in wiql
+    assert wiql.endswith("ORDER BY [System.ChangedDate] DESC")
+
+
+def test_build_search_wiql_no_keywords_lists_without_text_filter() -> None:
+    wiql = build_search_wiql([], state="all")
+    assert wiql == "SELECT [System.Id] FROM WorkItems WHERE [System.TeamProject] = @project ORDER BY [System.ChangedDate] DESC"
+
+
+def test_build_search_wiql_defaults_to_open_state() -> None:
+    # Covers all four built-in process templates' terminal state names (Agile/CMMI: 'Closed',
+    # Scrum/Basic: 'Done'; all: 'Removed') since search() doesn't know which one a project uses.
+    wiql = build_search_wiql(["auth"])
+    assert "[System.State] <> 'Closed'" in wiql
+    assert "[System.State] <> 'Done'" in wiql
+    assert "[System.State] <> 'Removed'" in wiql
+
+
+def test_build_search_wiql_closed_state() -> None:
+    wiql = build_search_wiql(["auth"], state="closed")
+    assert "[System.State] = 'Closed'" in wiql
+    assert "[System.State] = 'Done'" in wiql
+    assert "[System.State] = 'Removed'" in wiql
+    assert "<>" not in wiql
+
+
+def test_build_search_wiql_all_state_has_no_state_clause() -> None:
+    assert "System.State" not in build_search_wiql(["auth"], state="all")
+
+
+def test_build_search_wiql_multiple_keywords_are_anded() -> None:
+    wiql = build_search_wiql(["auth", "timeout"], state="all")
+    assert wiql.count(" AND ") == 2  # TeamProject AND keyword1 AND keyword2
+
+
+def test_build_search_wiql_since_adds_changed_date_clause() -> None:
+    wiql = build_search_wiql(["auth"], since="2026-08-10")
+    assert "[System.ChangedDate] >= '2026-08-10T00:00:00Z'" in wiql
+
+
+def test_build_search_wiql_escapes_single_quotes() -> None:
+    wiql = build_search_wiql(["it's broken"])
+    assert "it''s broken" in wiql
+
+
+def test_build_search_wiql_area_path_scopes_to_board() -> None:
+    wiql = build_search_wiql(["auth"], area_path="MyProj\\Data Team")
+    assert "[System.AreaPath] UNDER 'MyProj\\Data Team'" in wiql
+
+
+def test_build_search_wiql_no_area_path_by_default() -> None:
+    assert "AreaPath" not in build_search_wiql(["auth"])

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/tests/test_ado_issue_flow.py

@@ -13,6 +13,7 @@ from bmsdna.devtools.ado_issue import (
     create,
     delete,
     delete_comment,
+    search,
     update,
     update_comment,
 )
@@ -34,7 +35,7 @@ class FakeResponse:
             raise RuntimeError(f"HTTP {self.status_code}")
 
 
-def make_session(get_map: dict[str, dict] | None = None) -> MagicMock:
+def make_session(get_map: dict[str, dict] | None = None, wiql_ids: list[int] | None = None) -> MagicMock:
     session = MagicMock()
     get_map = get_map or {}
 
@@ -45,6 +46,8 @@ def make_session(get_map: dict[str, dict] | None = None) -> MagicMock:
         raise AssertionError(f"unexpected GET {url}")
 
     def fake_post(url, params: dict | None = None, **kwargs):
+        if "/_apis/wit/wiql" in url:
+            return FakeResponse({"workItems": [{"id": i} for i in (wiql_ids or [])]})
         if "/_apis/wit/attachments" in url:
             assert params is not None
             name = params["fileName"]
@@ -187,3 +190,59 @@ def test_delete_comment_hits_comment_id_endpoint() -> None:
 
     url = session.delete.call_args.args[0]
     assert url == "https://dev.azure.com/myorg/MyProj/_apis/wit/workItems/42/comments/7"
+
+
+def test_search_runs_wiql_then_batch_fetches_matched_fields() -> None:
+    session = make_session(
+        get_map={"/_apis/wit/workitems": {"value": [{"id": 42, "fields": {"System.Title": "Auth timeout bug", "System.State": "Active"}}]}},
+        wiql_ids=[42],
+    )
+
+    results = search(session, REMOTE, ["auth", "timeout"])
+
+    wiql_url, wiql_kwargs = session.post.call_args_list[0].args[0], session.post.call_args_list[0].kwargs
+    assert wiql_url == "https://dev.azure.com/myorg/MyProj/_apis/wit/wiql"
+    assert "auth" in wiql_kwargs["json"]["query"]
+    assert "timeout" in wiql_kwargs["json"]["query"]
+
+    get_url, get_kwargs = session.get.call_args.args[0], session.get.call_args.kwargs
+    assert get_url == "https://dev.azure.com/myorg/MyProj/_apis/wit/workitems"
+    assert get_kwargs["params"]["ids"] == "42"
+
+    assert results == [{"id": 42, "fields": {"System.Title": "Auth timeout bug", "System.State": "Active"}}]
+
+
+def test_search_skips_batch_fetch_when_no_matches() -> None:
+    session = make_session(wiql_ids=[])
+
+    results = search(session, REMOTE, ["nonexistent-keyword"])
+
+    session.get.assert_not_called()
+    assert results == []
+
+
+def test_search_with_board_resolves_area_path_and_scopes_wiql() -> None:
+    session = make_session(
+        get_map={
+            "teamsettings/teamfieldvalues": {"defaultValue": "MyProj\\Data Team"},
+            "/_apis/wit/workitems": {"value": []},
+        },
+        wiql_ids=[],
+    )
+
+    search(session, REMOTE, ["auth"], board="Data Team")
+
+    # Team field values lookup must happen before the WIQL query is built/run.
+    get_url = session.get.call_args_list[0].args[0]
+    assert "myorg/MyProj/Data%20Team/_apis/work/teamsettings/teamfieldvalues" in get_url
+
+    wiql_kwargs = session.post.call_args.kwargs
+    assert "[System.AreaPath] UNDER 'MyProj\\Data Team'" in wiql_kwargs["json"]["query"]
+
+
+def test_search_without_board_does_not_look_up_area_path() -> None:
+    session = make_session(wiql_ids=[])
+
+    search(session, REMOTE, ["auth"])
+
+    session.get.assert_not_called()  # no --board given, so no team field values lookup at all

bmsdna_devtools-0.8.0/tests/test_cli_pr_create.py

@@ -0,0 +1,132 @@
+"""`bdt pr create` must pass the parsed org/project/repo through to
+`az repos pr create` explicitly, rather than relying on `az`'s own remote
+auto-detection -- that auto-detect doesn't understand the SSH `v3` remote
+form at all, and separately, an `az devops configure -d project=...` default
+that happens to point at a *different* ADO project than the current repo's
+own silently makes `az` look for the PR's repository in the wrong project.
+"""
+
+import json
+from unittest.mock import MagicMock
+
+from typer.testing import CliRunner
+
+from bmsdna.devtools.cli import app
+from bmsdna.devtools.gitrepo import AdoRemote, GitHubRemote
+
+runner = CliRunner()
+
+
+def test_pr_create_passes_organization_project_repository_to_az(monkeypatch) -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
+    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0)
+
+    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
+    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "test"])
+
+    assert result.exit_code == 0, result.output
+    assert "--organization" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--organization") + 1] == "https://dev.azure.com/bmeurope"
+    assert "--project" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--project") + 1] == "BMS - CCMT2"
+    assert "--repository" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--repository") + 1] == "BMS - CCMT2"
+
+
+def test_pr_create_passes_labels_and_prints_web_link_for_ado(monkeypatch) -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
+    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
+    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout=json.dumps({"pullRequestId": 456, "title": "feat: widgets"}), stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "test", "--label", "bug", "--label", "urgent"])
+
+    assert result.exit_code == 0, result.output
+    assert "--labels" in captured_cmd
+    labels_idx = captured_cmd.index("--labels")
+    assert captured_cmd[labels_idx + 1 : labels_idx + 3] == ["bug", "urgent"]
+    assert "https://dev.azure.com/bmeurope/BMS%20-%20CCMT2/_git/BMS%20-%20CCMT2/pullrequest/456" in result.output
+    assert "PR #456: feat: widgets" in result.output
+    assert '"pullRequestId"' not in result.output  # the raw `az` JSON blob must not be dumped on success
+
+
+def test_pr_create_passes_labels_and_prints_web_link_for_github(monkeypatch) -> None:
+    remote = GitHubRemote("owner", "repo")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.has_build_policy", lambda gh, target: False)
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "bug"])
+
+    assert result.exit_code == 0, result.output
+    assert captured_cmd.count("--label") == 1
+    assert captured_cmd[captured_cmd.index("--label") + 1] == "bug"
+    assert "https://github.com/owner/repo/pull/7" in result.output
+
+
+def test_pr_create_fails_before_touching_gh_az_when_required_label_group_missing(monkeypatch) -> None:
+    monkeypatch.setattr(
+        "bmsdna.devtools.cli.pr_labels.required_label_groups",
+        lambda: {"risk": ["breaking", "non-breaking"]},
+    )
+
+    def fail_if_called(*args, **kwargs):
+        raise AssertionError("should not be reached — the missing-label check must run first")
+
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", fail_if_called)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "bug"])
+
+    assert result.exit_code != 0
+    assert "risk" in result.output
+    assert "breaking" in result.output
+
+
+def test_pr_create_proceeds_when_required_label_group_satisfied(monkeypatch) -> None:
+    remote = GitHubRemote("owner", "repo")
+    monkeypatch.setattr(
+        "bmsdna.devtools.cli.pr_labels.required_label_groups",
+        lambda: {"risk": ["breaking", "non-breaking"]},
+    )
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.has_build_policy", lambda gh, target: False)
+    monkeypatch.setattr(
+        "bmsdna.devtools.gh_pr.subprocess.run",
+        lambda cmd, **kwargs: MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr=""),
+    )
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "non-breaking"])
+
+    assert result.exit_code == 0, result.output

bmsdna_devtools-0.8.0/tests/test_gh_issue.py

@@ -0,0 +1,72 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from bmsdna.devtools.gh_issue import build_search_query, parse_comment_id, parse_issue_number, search
+
+
+@pytest.mark.parametrize(
+    "url,expected",
+    [
+        ("https://github.com/owner/repo/issues/42", "42"),
+        ("https://github.com/owner/repo/issues/42/", "42"),
+        ("http://github.com/owner/repo/issues/1", "1"),
+    ],
+)
+def test_parse_issue_number(url: str, expected: str) -> None:
+    assert parse_issue_number(url) == expected
+
+
+def test_parse_comment_id_present() -> None:
+    url = "https://github.com/owner/repo/issues/42#issuecomment-123456789"
+    assert parse_comment_id(url) == "123456789"
+
+
+def test_parse_comment_id_absent() -> None:
+    assert parse_comment_id("https://github.com/owner/repo/issues/42") is None
+
+
+def test_build_search_query_keywords_only() -> None:
+    assert build_search_query(["auth", "timeout"], None) == "auth timeout sort:updated-desc"
+
+
+def test_build_search_query_adds_updated_qualifier() -> None:
+    assert build_search_query(["auth"], "2026-08-10") == "auth sort:updated-desc updated:>=2026-08-10"
+
+
+def test_build_search_query_no_keywords_still_scopes_by_date() -> None:
+    assert build_search_query([], "2026-08-10") == "sort:updated-desc updated:>=2026-08-10"
+
+
+def test_build_search_query_always_sorts_by_updated_desc() -> None:
+    # search()'s "most recently updated first" ordering depends on this — GitHub's
+    # default --search order is text relevance, not recency.
+    assert "sort:updated-desc" in build_search_query(["auth"], None)
+
+
+def test_search_defaults_to_open_state(monkeypatch) -> None:
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="[]", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_issue.subprocess.run", fake_run)
+
+    search("gh", [], None, 10)
+
+    assert captured_cmd[captured_cmd.index("--state") + 1] == "open"
+
+
+def test_search_passes_through_requested_state(monkeypatch) -> None:
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="[]", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_issue.subprocess.run", fake_run)
+
+    search("gh", ["auth"], None, 10, state="all")
+
+    assert captured_cmd[captured_cmd.index("--state") + 1] == "all"

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/tests/test_gh_pr.py

@@ -1,6 +1,8 @@
+from unittest.mock import MagicMock
+
 import pytest
 
-from bmsdna.devtools.gh_pr import check_bucket, check_label, merge_conflict_message, protection_requires_status_checks
+from bmsdna.devtools.gh_pr import check_bucket, check_label, create, merge_conflict_message, protection_requires_status_checks
 
 # Real statusCheckRollup entries captured from `gh pr view 13902 -R cli/cli --json statusCheckRollup`.
 COMPLETED_SUCCESS_CHECK_RUN = {
@@ -70,3 +72,33 @@ def test_protection_requires_status_checks_true_when_configured() -> None:
 @pytest.mark.parametrize("protection", [{}, {"required_status_checks": None}])
 def test_protection_requires_status_checks_false_when_absent(protection: dict) -> None:
     assert protection_requires_status_checks(protection) is False
+
+
+def test_create_passes_repeatable_label_flags(monkeypatch) -> None:
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    returncode, url = create("gh", "main", [], labels=["bug", "urgent"])
+
+    assert returncode == 0
+    assert url == "https://github.com/owner/repo/pull/7"
+    assert captured_cmd.count("--label") == 2
+    assert captured_cmd[captured_cmd.index("--label") + 1] == "bug"
+
+
+def test_create_returns_none_url_on_failure(monkeypatch, capsys) -> None:
+    def fake_run(cmd, **kwargs):
+        return MagicMock(returncode=1, stdout="", stderr="label 'nope' not found")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    returncode, url = create("gh", "main", [], labels=["nope"])
+
+    assert returncode == 1
+    assert url is None
+    assert "not found" in capsys.readouterr().err

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/tests/test_pr_build.py

@@ -1,6 +1,7 @@
 import pytest
 
-from bmsdna.devtools.pr_build import merge_conflict_message, policy_configs_include_branch
+from bmsdna.devtools.gitrepo import AdoRemote
+from bmsdna.devtools.pr_build import merge_conflict_message, policy_configs_include_branch, pr_web_url
 
 REPO_ID = "0cd3a822-389e-416e-a4fa-b73f988c2930"
 
@@ -95,3 +96,8 @@ def test_policy_configs_include_branch_matches_default_branch_scope() -> None:
     }
     assert policy_configs_include_branch([default_branch_policy], REPO_ID, "main", "refs/heads/main") is True
     assert policy_configs_include_branch([default_branch_policy], REPO_ID, "test", "refs/heads/main") is False
+
+
+def test_pr_web_url_is_the_browsable_page_not_the_rest_api_url() -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    assert pr_web_url(remote, 123) == "https://dev.azure.com/bmeurope/BMS%20-%20CCMT2/_git/BMS%20-%20CCMT2/pullrequest/123"

bmsdna_devtools-0.8.0/tests/test_pr_labels.py

@@ -0,0 +1,56 @@
+from bmsdna.devtools.pr_labels import format_missing_groups_error, missing_label_groups, required_label_groups
+
+
+def write_pyproject(tmp_path, body: str):
+    (tmp_path / "pyproject.toml").write_text(body)
+    return tmp_path
+
+
+def test_required_label_groups_empty_when_no_pyproject(tmp_path) -> None:
+    assert required_label_groups(tmp_path) == {}
+
+
+def test_required_label_groups_empty_when_table_absent(tmp_path) -> None:
+    write_pyproject(tmp_path, "[tool.bdt.ado]\nboard = 'x'\n")
+    assert required_label_groups(tmp_path) == {}
+
+
+def test_required_label_groups_reads_named_groups(tmp_path) -> None:
+    write_pyproject(
+        tmp_path,
+        "[tool.bdt.pr.required_labels]\n"
+        'type = ["bug", "feature", "chore"]\n'
+        'risk = ["breaking", "non-breaking"]\n',
+    )
+    assert required_label_groups(tmp_path) == {
+        "type": ["bug", "feature", "chore"],
+        "risk": ["breaking", "non-breaking"],
+    }
+
+
+def test_missing_label_groups_none_missing_when_all_satisfied() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["feature", "breaking"]) == {}
+
+
+def test_missing_label_groups_reports_unsatisfied_group() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["feature"]) == {"risk": ["breaking", "non-breaking"]}
+
+
+def test_missing_label_groups_matches_case_insensitively() -> None:
+    groups = {"risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["Breaking"]) == {}
+    assert missing_label_groups(groups, ["BREAKING"]) == {}
+
+
+def test_missing_label_groups_reports_all_when_no_labels_given() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, []) == groups
+
+
+def test_format_missing_groups_error_lists_group_name_and_choices() -> None:
+    msg = format_missing_groups_error({"risk": ["breaking", "non-breaking"]})
+    assert "risk" in msg
+    assert "breaking" in msg
+    assert "non-breaking" in msg

{bmsdna_devtools-0.6.0 → bmsdna_devtools-0.8.0}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "bmsdna-devtools"
-version = "0.6.0"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "requests" },

bmsdna_devtools-0.6.0/tests/test_cli_pr_create.py

@@ -1,43 +0,0 @@
-"""`bdt pr create` must pass the parsed org/project/repo through to
-`az repos pr create` explicitly, rather than relying on `az`'s own remote
-auto-detection -- that auto-detect doesn't understand the SSH `v3` remote
-form at all, and separately, an `az devops configure -d project=...` default
-that happens to point at a *different* ADO project than the current repo's
-own silently makes `az` look for the PR's repository in the wrong project.
-"""
-
-from unittest.mock import MagicMock
-
-from typer.testing import CliRunner
-
-from bmsdna.devtools.cli import app
-from bmsdna.devtools.gitrepo import AdoRemote
-
-runner = CliRunner()
-
-
-def test_pr_create_passes_organization_project_repository_to_az(monkeypatch) -> None:
-    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
-    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
-    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
-    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
-    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
-
-    captured_cmd: list[str] = []
-
-    def fake_run(cmd, **kwargs):
-        captured_cmd[:] = cmd
-        return MagicMock(returncode=0)
-
-    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
-    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
-
-    result = runner.invoke(app, ["pr", "create", "--target", "test"])
-
-    assert result.exit_code == 0, result.output
-    assert "--organization" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--organization") + 1] == "https://dev.azure.com/bmeurope"
-    assert "--project" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--project") + 1] == "BMS - CCMT2"
-    assert "--repository" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--repository") + 1] == "BMS - CCMT2"

bmsdna_devtools-0.6.0/tests/test_gh_issue.py

@@ -1,24 +0,0 @@
-import pytest
-
-from bmsdna.devtools.gh_issue import parse_comment_id, parse_issue_number
-
-
-@pytest.mark.parametrize(
-    "url,expected",
-    [
-        ("https://github.com/owner/repo/issues/42", "42"),
-        ("https://github.com/owner/repo/issues/42/", "42"),
-        ("http://github.com/owner/repo/issues/1", "1"),
-    ],
-)
-def test_parse_issue_number(url: str, expected: str) -> None:
-    assert parse_issue_number(url) == expected
-
-
-def test_parse_comment_id_present() -> None:
-    url = "https://github.com/owner/repo/issues/42#issuecomment-123456789"
-    assert parse_comment_id(url) == "123456789"
-
-
-def test_parse_comment_id_absent() -> None:
-    assert parse_comment_id("https://github.com/owner/repo/issues/42") is None