bmsdna-devtools 0.22.0__tar.gz → 0.23.0__tar.gz

bmsdna_devtools-0.22.0/README.md → bmsdna_devtools-0.23.0/PKG-INFO

@@ -1,3 +1,14 @@
+Metadata-Version: 2.5
+Name: bmsdna-devtools
+Version: 0.23.0
+Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
+Requires-Python: >=3.14
+Requires-Dist: pgdevkit[db]>=0.7.1
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.26.7
+Description-Content-Type: text/markdown
+
 # bmsdna-devtools
 
 Shared developer tooling for BMS projects: PR build/check status, PR
@@ -160,6 +171,23 @@ 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.
 
+`[tool.bdt.pr.scope_labels]` in pyproject.toml can auto-apply a label based on
+the "scope" of the HEAD commit's conventional-commit subject (the
+`type(scope): description` format `bdt commit` itself expects, e.g.
+`feat(customers): ...`):
+
+```toml
+[tool.bdt.pr.scope_labels]
+customers = "e2e-customers"
+billing = "e2e-billing"
+```
+
+With the above, creating a PR whose HEAD commit is `feat(customers): add
+widget` automatically adds the `e2e-customers` label (merged with, not
+replacing, any explicit `--label`). No match, no `[tool.bdt.pr.scope_labels]`
+table, or a commit subject without a `(scope)` all mean no label gets added —
+opt-in, so repos that don't configure it see no change in behavior.
+
 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

bmsdna_devtools-0.22.0/PKG-INFO → bmsdna_devtools-0.23.0/README.md

@@ -1,14 +1,3 @@
-Metadata-Version: 2.5
-Name: bmsdna-devtools
-Version: 0.22.0
-Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
-Requires-Python: >=3.14
-Requires-Dist: pgdevkit[db]>=0.7.1
-Requires-Dist: requests>=2.32.0
-Requires-Dist: rich>=13.0.0
-Requires-Dist: typer>=0.26.7
-Description-Content-Type: text/markdown
-
 # bmsdna-devtools
 
 Shared developer tooling for BMS projects: PR build/check status, PR
@@ -171,6 +160,23 @@ 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.
 
+`[tool.bdt.pr.scope_labels]` in pyproject.toml can auto-apply a label based on
+the "scope" of the HEAD commit's conventional-commit subject (the
+`type(scope): description` format `bdt commit` itself expects, e.g.
+`feat(customers): ...`):
+
+```toml
+[tool.bdt.pr.scope_labels]
+customers = "e2e-customers"
+billing = "e2e-billing"
+```
+
+With the above, creating a PR whose HEAD commit is `feat(customers): add
+widget` automatically adds the `e2e-customers` label (merged with, not
+replacing, any explicit `--label`). No match, no `[tool.bdt.pr.scope_labels]`
+table, or a commit subject without a `(scope)` all mean no label gets added —
+opt-in, so repos that don't configure it see no change in behavior.
+
 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

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/ado_issue.py

@@ -49,6 +49,7 @@ import requests
 from .bdt_config import load_bdt_table
 from .cli_tools import ensure_agent_session_note
 from .gitrepo import AdoRemote
+from .pr_issue_link import PR_AVAILABLE_LABEL
 from .pr_markdown import build_comment_content_html
 
 COMMENTS_API_VERSION = "7.1-preview.4"
@@ -204,6 +205,39 @@ def get_valid_states(session: requests.Session, remote: AdoRemote, work_item_typ
     return [s["name"] for s in r.json()["value"]]
 
 
+def get_work_item_tags(session: requests.Session, remote: AdoRemote, work_item_id: int) -> list[str]:
+    r = session.get(
+        f"{_base_url(remote)}/_apis/wit/workitems/{work_item_id}",
+        params={"fields": "System.Tags", "api-version": "7.1"},
+    )
+    if r.status_code == 404:
+        sys.exit(f"Work item #{work_item_id} not found in project '{remote.project}'.")
+    r.raise_for_status()
+    raw = r.json().get("fields", {}).get("System.Tags") or ""
+    return [t.strip() for t in raw.split(";") if t.strip()]
+
+
+def add_tag(session: requests.Session, remote: AdoRemote, work_item_id: int, tag: str) -> None:
+    """Add `tag` to work item `work_item_id`'s tags, alongside whatever's already there.
+
+    `update_work_item`'s tags op replaces the whole `System.Tags` field (there's no
+    Azure DevOps "add one tag" patch op), so this reads the current tags first and only
+    PATCHes if `tag` isn't already among them -- otherwise a second `pr create --issue`
+    against the same work item would keep re-sending an unchanged value.
+    """
+    tags = get_work_item_tags(session, remote, work_item_id)
+    if any(t.casefold() == tag.casefold() for t in tags):
+        return
+    update_work_item(session, remote, work_item_id, tags=[*tags, tag])
+
+
+def add_pr_available_tag(session: requests.Session, remote: AdoRemote, work_item_id: int) -> None:
+    """Tag work item `work_item_id` `pr-available` -- the Azure DevOps equivalent of the
+    GitHub `pr-available` label (Azure DevOps work items have no label concept; tags are the
+    closest equivalent, same as `ado_issue.py`'s own `--tag` create/update flag)."""
+    add_tag(session, remote, work_item_id, PR_AVAILABLE_LABEL)
+
+
 def delete_work_item(session: requests.Session, remote: AdoRemote, work_item_id: int) -> None:
     """Soft-delete: moves the work item to the project's Recycle Bin, where it can be restored.
 

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/cli.py

@@ -17,10 +17,10 @@ from . import env_config
 from . import find_repo as find_repo_mod
 from . import gh_issue, gh_pr
 from . import logs as logs_mod
-from . import pr_build, pr_labels, worktree as worktree_mod
+from . import pr_build, pr_issue_link, pr_labels, pull as pull_mod, worktree as worktree_mod
 from .ado_auth import auth_header
 from .cli_tools import detect_agent_session, require_az, require_gh
-from .gitrepo import AdoRemote, GitHubRemote, current_branch, current_remote
+from .gitrepo import AdoRemote, GitHubRemote, current_branch, current_remote, head_commit_subject
 
 # Non-ASCII output (checkmarks, en-dashes in ADO project names, etc.) needs a
 # UTF-8 stream — the default Windows console codepage isn't UTF-8, and would
@@ -120,6 +120,53 @@ def _after_create(step: Callable[[], None], label: str) -> None:
         print(f"Warning: PR created, but {label} failed: {e}")
 
 
+def _link_and_label_github(gh: str, remote: GitHubRemote, issue_numbers: list[int]) -> None:
+    """Link every issue in `issue_numbers`, plus every issue `find_issue_refs_in_body` finds in
+    the PR's actual body, to the current branch's PR, and label each `pr-available`.
+
+    Best-effort per issue -- one bad/inaccessible issue number shouldn't stop the others from
+    being linked/labeled; failures are collected and surfaced together to the caller (which
+    wraps this in `_after_create`, so they're reported as a warning, not a failed `pr create`).
+    A no-op (no `gh` calls at all) when there's nothing to link.
+    """
+    pr_number, body = gh_pr.get_pr_body(gh)
+    all_numbers = list(dict.fromkeys([*issue_numbers, *pr_issue_link.find_issue_refs_in_body(body, remote)]))
+    if not all_numbers:
+        return
+    gh_issue.ensure_pr_available_label(gh)
+    errors: list[str] = []
+    for number in all_numbers:
+        try:
+            body = gh_pr.link_issue_to_pr(gh, pr_number, body, number)
+            gh_issue.add_pr_available_label(gh, number)
+        except SystemExit as e:
+            errors.append(f"#{number}: {e}")
+    if errors:
+        raise RuntimeError("; ".join(errors))
+
+
+def _link_and_label_ado(session: requests.Session, remote: AdoRemote, pr_id: int, description: str, issue_numbers: list[int]) -> None:
+    """Azure DevOps equivalent of `_link_and_label_github`: link every issue in `issue_numbers`,
+    plus every work item `find_issue_refs_in_body` finds in the PR's description, to PR `pr_id`,
+    and tag each `pr-available`.
+
+    Best-effort per work item -- one bad/inaccessible number shouldn't stop the others from being
+    linked/tagged; failures (a REST error, or a 404 `sys.exit` from deeper in `ado_issue.py`) are
+    collected and surfaced together to the caller (which wraps this in `_after_create`, so they're
+    reported as a warning, not a failed `pr create`).
+    """
+    all_numbers = list(dict.fromkeys([*issue_numbers, *pr_issue_link.find_issue_refs_in_body(description, remote)]))
+    errors: list[str] = []
+    for number in all_numbers:
+        try:
+            pr_build.link_work_item(session, remote, pr_id, number)
+            ado_issue.add_pr_available_tag(session, remote, number)
+        except (requests.RequestException, SystemExit) as e:
+            errors.append(f"#{number}: {e}")
+    if errors:
+        raise RuntimeError("; ".join(errors))
+
+
 @pr_app.command("create")
 def pr_create(
     target: str = typer.Option("main", "--target", help="Target branch (e.g. main, test)"),
@@ -134,7 +181,8 @@ def pr_create(
         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.",
+        "named group before the PR is created. [tool.bdt.pr.scope_labels] can auto-add a label based "
+        "on the HEAD commit's conventional-commit scope (e.g. `feat(customers): ...` -> a configured label).",
     ),
     screenshot: list[str] = typer.Option(
         [], "--screenshot", help="Path to an image to attach to the PR description (repeatable)"
@@ -142,6 +190,14 @@ def pr_create(
     file: list[str] = typer.Option(
         [], "--file", help="Path to an arbitrary file to attach to the PR description as a linked attachment (repeatable)"
     ),
+    issue: list[str] = typer.Option(
+        [],
+        "--issue",
+        help="Issue number or URL (GitHub issue or Azure DevOps work item) to link to this PR (repeatable). "
+        "Each linked issue/work item is also labeled/tagged 'pr-available'. Independent of this flag, the PR "
+        "body is scanned for 'Fixes/Closes/Resolves #NR' and full issue/work-item URLs; every match found "
+        "there gets the same link + label/tag treatment automatically.",
+    ),
     pat: str | None = typer.Option(
         None,
         "--pat",
@@ -158,12 +214,30 @@ def pr_create(
         if not Path(path).is_file():
             raise typer.BadParameter(f"File not found: {path}", param_hint="--file")
 
+    scope_label_map = pr_labels.scope_labels()
+    if scope_label_map:
+        scope = commit_mod.conventional_commit_scope(head_commit_subject())
+        auto_label = pr_labels.label_for_scope(scope_label_map, scope)
+        if auto_label and auto_label.lower() not in {existing.lower() for existing in label}:
+            print(f"Auto-applying label '{auto_label}' for scope '{scope}' ([tool.bdt.pr.scope_labels])")
+            label = [*label, auto_label]
+
     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()
+
+    issue_numbers: list[int] = []
+    for ref in issue:
+        try:
+            issue_numbers.append(pr_issue_link.parse_issue_ref(ref, remote))
+        except ValueError as e:
+            raise typer.BadParameter(str(e), param_hint="--issue") from e
+    issue_numbers = list(dict.fromkeys(issue_numbers))
+
     source_branch = current_branch()
+
     pr_url: str | None = None
     if isinstance(remote, GitHubRemote):
         gh = require_gh()
@@ -171,6 +245,8 @@ def pr_create(
         build_policy = gh_pr.has_build_policy(gh, target)
         if returncode == 0 and (screenshot or file):
             _after_create(lambda: gh_pr.add_attachments(gh, remote.owner, remote.repo, source_branch, screenshot, file), "attaching screenshots/files")
+        if returncode == 0:
+            _after_create(lambda: _link_and_label_github(gh, remote, issue_numbers), "linking issue(s) / setting 'pr-available' label")
     else:
         az = require_az()
         cmd = [
@@ -219,6 +295,17 @@ def pr_create(
                 pr_build.ensure_session_note(session, remote, pr)
 
             _after_create(_finish, "attaching screenshots/files and/or noting the agent session")
+        if returncode == 0:
+            # Fetches the PR fresh via `pr_build.get_pr` rather than trusting `pr_json` -- `az`
+            # can exit 0 with stdout that isn't clean JSON (e.g. a deprecation banner ahead of
+            # it), which already leaves `pr_json` as None above; gating issue-linking on it too
+            # would then silently skip it instead of at least warning, unlike every other
+            # best-effort step here.
+            def _link_issues() -> None:
+                pr = pr_build.get_pr(session, remote, source_branch, target)
+                _link_and_label_ado(session, remote, pr["pullRequestId"], pr.get("description") or "", issue_numbers)
+
+            _after_create(_link_issues, "linking work item(s) / setting 'pr-available' tag")
 
     if returncode == 0 and pr_url:
         print(f"\n{pr_url}")
@@ -639,6 +726,34 @@ def worktree(
     worktree_mod.create(name, base=base, env_file=env_file, submodules=submodules, install_cmd=install_cmd)
 
 
+@app.command()
+def pull(
+    remote: str = typer.Option(
+        "origin",
+        "--remote",
+        help="Remote to pull main/master and the default branch from (the current branch's own tracking "
+        "branch step always follows its real configured upstream, regardless of this)",
+    ),
+    no_default: bool = typer.Option(
+        False,
+        "--no-default",
+        help="Don't also pull the repo's DEFAULT branch -- skip this when the current branch was already "
+        "branched from main/master, since pulling it again would be redundant",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Print what would be pulled, without doing it"),
+    pull_args: list[str] = typer.Argument(
+        None,
+        help="Extra flags passed through to every `git pull` step, e.g. `-- --rebase --ff-only` (put them after `--`)",
+    ),
+) -> None:
+    """Bring the current branch up to date from three sources: its own remote tracking branch, the
+    remote's main/master branch, and the repo's DEFAULT branch (unless --no-default) -- each a
+    separate `git pull`, stopping with a clear error (and the exact command to re-run) if any step
+    hits a merge conflict.
+    """
+    pull_mod.run(remote=remote, no_default=no_default, dry_run=dry_run, pull_args=pull_args or [])
+
+
 @app.command("find-repo")
 def find_repo_cmd(
     name: str,

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/gh_issue.py

@@ -27,6 +27,7 @@ from pathlib import Path
 from .bdt_config import load_bdt_table
 from .cli_tools import ensure_agent_session_note
 from .gh_pr import push_assets
+from .pr_issue_link import PR_AVAILABLE_LABEL
 from .pr_markdown import build_attachments_section, build_comment_content, build_screenshots_section
 
 _COMMENT_ID_RE = re.compile(r"#issuecomment-(\d+)")
@@ -166,6 +167,40 @@ def create(
         print(f"Attached {len(screenshot_paths)} screenshot(s), {len(file_paths)} file(s) to issue #{number}")
 
 
+def _label_exists(gh: str, name: str) -> bool:
+    out = _run_gh(gh, ["label", "list", "--search", name, "--json", "name"])
+    names = {label["name"].casefold() for label in (json.loads(out) if out else [])}
+    return name.casefold() in names
+
+
+def ensure_pr_available_label(gh: str) -> None:
+    """Make sure the repo-wide `pr-available` label exists, creating it if not -- unlike Azure
+    DevOps tags (freeform), `gh issue edit --add-label` rejects a label name GitHub doesn't
+    already know about (see `gh_pr.create`'s docstring). Only creates the label when it's
+    actually missing, so an existing custom color/description isn't clobbered.
+
+    Call this once per `pr create` invocation, before any `add_pr_available_label` calls --
+    it's the same repo-wide label being checked/created each time, not a per-issue thing, so a
+    caller linking several issues in one go should only pay for this lookup once.
+    """
+    if not _label_exists(gh, PR_AVAILABLE_LABEL):
+        _run_gh(
+            gh,
+            [
+                "label", "create", PR_AVAILABLE_LABEL,
+                "--color", "0E8A16",
+                "--description", "A PR exists that addresses this issue",
+            ],
+        )
+
+
+def add_pr_available_label(gh: str, number: int) -> None:
+    """Label issue `number` `pr-available`. Caller must have already called
+    `ensure_pr_available_label` (once, not per-issue) so the label exists on the repo first.
+    """
+    _run_gh(gh, ["issue", "edit", str(number), "--add-label", PR_AVAILABLE_LABEL])
+
+
 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

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/gh_pr.py

@@ -18,6 +18,7 @@ import tempfile
 import time
 from pathlib import Path
 
+from . import pr_issue_link
 from .cli_tools import CLI_TIMEOUT_SECS, EXIT_NEEDS_APPROVAL, PollHeartbeat, detect_agent_session, ensure_agent_session_note, is_claude_code
 from .pr_markdown import build_attachments_section, build_comment_content, build_screenshots_section
 
@@ -490,6 +491,37 @@ def ensure_session_note(gh: str) -> None:
         pass
 
 
+def get_pr_body(gh: str) -> tuple[int, str]:
+    """(PR number, PR body) for the current branch's PR -- used by issue-linking, which needs
+    the body actually stored (e.g. autofilled from the commit message via `--fill`), not
+    whatever a caller happened to pass to `pr create`.
+    """
+    pr = _run_gh_json(gh, ["pr", "view", "--json", "number,body"])
+    return pr["number"], pr.get("body") or ""
+
+
+def link_issue_to_pr(gh: str, pr_number: int, body: str, issue_number: int) -> str:
+    """Make sure `body` (the PR's current body) references `issue_number` via a GitHub closing
+    keyword, so GitHub shows this as a genuinely linked PR (appearing in the issue's
+    "Development" sidebar and auto-closing it on merge) -- a plain `#N` mention elsewhere (only
+    in a comment, or just prose referencing it, say) doesn't get that treatment, so it isn't
+    mistaken for one already being present (see `pr_issue_link.github_body_already_closes`). A
+    no-op if `body` already has a real closing-keyword reference to the issue (e.g. because this
+    number came from scanning the body for one in the first place).
+
+    Returns the (possibly unchanged) new body -- callers linking more than one issue in a row
+    pass this back in as `body` for the next call, so each edit builds on the last instead of
+    re-fetching or clobbering a previous append.
+    """
+    if pr_issue_link.github_body_already_closes(body, issue_number):
+        return body
+    new_body = f"{body.rstrip()}\n\nFixes #{issue_number}\n".lstrip("\n")
+    r = _run([gh, "pr", "edit", str(pr_number), "--body", new_body], capture_output=True, encoding="utf-8")
+    if r.returncode != 0:
+        sys.exit((r.stderr or r.stdout).strip() or "`gh pr edit` failed")
+    return new_body
+
+
 def publish(gh: str) -> None:
     """Mark the current branch's draft PR as ready for review."""
     r = _run([gh, "pr", "ready"], capture_output=True, encoding="utf-8")

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/gitrepo.py

@@ -50,6 +50,12 @@ def current_branch(cwd: str | None = None) -> str:
     return _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
 
 
+def head_commit_subject(cwd: str | None = None) -> str:
+    """Subject line of the current branch's HEAD commit -- e.g. used to derive a PR's
+    conventional-commit scope (`type(scope): ...`) locally, before the PR exists."""
+    return _run_git(["log", "-1", "--format=%s"], cwd=cwd)
+
+
 def origin_url(cwd: str | None = None) -> str:
     return _run_git(["remote", "get-url", "origin"], cwd=cwd)
 

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/pr_build.py

@@ -305,6 +305,21 @@ def update(
     print(f"Updated PR #{pr_id}")
 
 
+def link_work_item(session: requests.Session, remote: AdoRemote, pr_id: int, work_item_id: int) -> None:
+    """Link work item `work_item_id` to PR `pr_id`, so it shows up in the PR's "Work Items" tab
+    (and the work item's own "Development" links) -- the Azure DevOps equivalent of GitHub's
+    closing-keyword PR<->issue link, via the dedicated Pull Request Work Items REST resource
+    (POST .../pullRequests/{pr_id}/workitems/{work_item_id}, the same one `az repos pr work-item
+    add` itself calls). Idempotent -- linking an already-linked work item just re-confirms it.
+    """
+    r = session.post(
+        f"{_base_url(remote)}/_apis/git/repositories/{quote(remote.repo, safe='')}/pullRequests/{pr_id}/workitems/{work_item_id}",
+        params={"api-version": "7.1"},
+        timeout=HTTP_TIMEOUT_SECS,
+    )
+    r.raise_for_status()
+
+
 def publish(session: requests.Session, remote: AdoRemote, pr: dict) -> None:
     """Mark a draft PR as ready for review (clears isDraft)."""
     pr_id = pr["pullRequestId"]

bmsdna_devtools-0.23.0/bmsdna/devtools/pr_issue_link.py

@@ -0,0 +1,108 @@
+"""Parse `bdt pr create --issue` references and scan a PR body for issue/work-item mentions.
+
+Both feed the same downstream treatment (see `cli.py::pr_create`): link the issue/work item to
+the PR and label it `pr-available` (a GitHub label, or an Azure DevOps tag -- Azure DevOps has no
+label concept of its own, tags are the closest equivalent, same as `ado_issue.py`'s `--tag`).
+
+An issue number alone is only unique within a single tracker -- same reasoning `gh_issue.py`'s
+`_extract_issue_numbers` uses for board membership -- so a URL is only accepted here when it
+names *this* repo's own tracker (same GitHub owner/repo, or same Azure DevOps org). A URL for
+some other repo/org is rejected/ignored rather than silently acted on.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .gitrepo import AdoRemote, GitHubRemote
+
+PR_AVAILABLE_LABEL = "pr-available"
+
+# GitHub's own PR-body/commit-message closing keywords -- see
+# https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+_GITHUB_KEYWORD_RE = re.compile(r"\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s*:?\s*#(\d+)", re.IGNORECASE)
+
+# Matches a GitHub issue URL, e.g. https://github.com/owner/repo/issues/42. The `(?<![\w-])`
+# lookbehind anchors "github.com" to an actual host boundary (start of string, `//`, or a `.`
+# subdomain separator) -- without it, a URL on an unrelated domain that merely *contains* the
+# substring "github.com" (e.g. https://notgithub.com/owner/repo/issues/42, or any host ending in
+# "-github.com") would be misidentified as pointing at github.com itself.
+_GITHUB_ISSUE_URL_RE = re.compile(r"(?<![\w-])github\.com/([^/\s]+)/([^/\s]+)/issues/(\d+)")
+
+# Matches an Azure DevOps work item URL, e.g. https://dev.azure.com/org/project/_workitems/edit/42
+# (also the older org.visualstudio.com host form). Same host-boundary reasoning as
+# `_GITHUB_ISSUE_URL_RE` for the "dev.azure.com" branch; the "*.visualstudio.com" branch's
+# `[^./\s]+` group already only captures a single dot-delimited label, so it can't be fooled the
+# same way.
+_ADO_WORK_ITEM_URL_RE = re.compile(r"(?:(?<![\w-])dev\.azure\.com/([^/\s]+)|([^./\s]+)\.visualstudio\.com)/\S*_workitems/edit/(\d+)")
+
+
+def parse_issue_ref(ref: str, remote: AdoRemote | GitHubRemote) -> int:
+    """A bare issue/work-item number, or a URL naming *this* repo's own tracker, -> its number.
+
+    Raises ValueError (with a message suitable to surface via `typer.BadParameter`) for anything
+    else: an unparseable value, or a URL for a different repo/org than `remote`.
+    """
+    ref = ref.strip()
+    if ref.isdigit():
+        return int(ref)
+
+    if isinstance(remote, GitHubRemote):
+        match = _GITHUB_ISSUE_URL_RE.search(ref)
+        if match and match.group(1).casefold() == remote.owner.casefold() and match.group(2).casefold() == remote.repo.casefold():
+            return int(match.group(3))
+        raise ValueError(f"'{ref}' isn't a bare issue number or a github.com/{remote.owner}/{remote.repo}/issues/<N> URL")
+
+    match = _ADO_WORK_ITEM_URL_RE.search(ref)
+    if match:
+        org = match.group(1) or match.group(2)
+        if org and org.casefold() == remote.org.casefold():
+            return int(match.group(3))
+    raise ValueError(f"'{ref}' isn't a bare work item number or a dev.azure.com/{remote.org}/.../_workitems/edit/<N> URL")
+
+
+def github_body_already_closes(body: str, issue_number: int) -> bool:
+    """True if `body` already contains a GitHub closing-keyword reference (`Fixes`/`Closes`/
+    `Resolves #N`, any tense/plural form) to `issue_number`.
+
+    Deliberately narrower than "the body mentions #N anywhere" -- a plain, non-keyword mention
+    (e.g. "see #42 for background") doesn't make GitHub treat the PR as genuinely linked to that
+    issue (no Development-sidebar entry, no auto-close on merge), so it must not be mistaken for
+    one already being present.
+    """
+    return any(int(m) == issue_number for m in _GITHUB_KEYWORD_RE.findall(body))
+
+
+def find_issue_refs_in_body(body: str | None, remote: AdoRemote | GitHubRemote) -> list[int]:
+    """Issue/work-item numbers mentioned in `body` that belong to *this* repo's own tracker, in
+    first-seen order.
+
+    GitHub: `Fixes #N`/`Closes #N`/`Resolves #N` (and their tense/plural variants) plus full
+    issue URLs for this owner/repo. Azure DevOps: full work-item URLs for this org only -- Azure
+    DevOps has no bare-`#N` keyword syntax of its own for this (unlike GitHub's, `AB#N` is a
+    commit-message-only linking convention, not something `pr create`'s body scan is asked to
+    understand here).
+    """
+    if not body:
+        return []
+    numbers: list[int] = []
+    seen: set[int] = set()
+
+    def _add(n: int) -> None:
+        if n not in seen:
+            seen.add(n)
+            numbers.append(n)
+
+    if isinstance(remote, GitHubRemote):
+        for match in _GITHUB_KEYWORD_RE.finditer(body):
+            _add(int(match.group(1)))
+        for match in _GITHUB_ISSUE_URL_RE.finditer(body):
+            if match.group(1).casefold() == remote.owner.casefold() and match.group(2).casefold() == remote.repo.casefold():
+                _add(int(match.group(3)))
+    else:
+        for match in _ADO_WORK_ITEM_URL_RE.finditer(body):
+            org = match.group(1) or match.group(2)
+            if org and org.casefold() == remote.org.casefold():
+                _add(int(match.group(3)))
+
+    return numbers

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.23.0}/bmsdna/devtools/pr_labels.py

@@ -10,6 +10,20 @@ 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.
+
+Also: scope -> label auto-labeling, configured under `[tool.bdt.pr.scope_labels]`:
+
+    [tool.bdt.pr.scope_labels]
+    customers = "e2e-customers"
+    billing = "e2e-billing"
+
+`bdt pr create` derives the "scope" from the HEAD commit's conventional-commit
+subject using the same parser `bdt commit` itself enforces
+(`commit.conventional_commit_scope`, e.g. `feat(customers): ...` -> scope
+"customers"). If the derived scope has a configured label, that label is
+added to the PR's `--label` list automatically (deduplicated against any
+explicitly-passed `--label`). Opt-in: with no `[tool.bdt.pr.scope_labels]`
+table, this is a no-op and behavior is unchanged.
 """
 
 from __future__ import annotations
@@ -27,6 +41,24 @@ def required_label_groups(start: Path | None = None) -> dict[str, list[str]]:
     return {name: choices for name, choices in raw.items() if isinstance(choices, list)}
 
 
+def scope_labels(start: Path | None = None) -> dict[str, str]:
+    """`[tool.bdt.pr.scope_labels]` -> {scope: label to auto-apply}."""
+    raw = load_bdt_table("pr", start).get("scope_labels", {})
+    if not isinstance(raw, dict):
+        return {}
+    return {name: label for name, label in raw.items() if isinstance(label, str)}
+
+
+def label_for_scope(scope_label_map: dict[str, str], scope: str | None) -> str | None:
+    """The configured label for `scope`, matched case-insensitively (same
+    convention as `missing_label_groups`), or None if `scope` is unset or
+    unconfigured."""
+    if not scope:
+        return None
+    lowered = {name.lower(): label for name, label in scope_label_map.items()}
+    return lowered.get(scope.lower())
+
+
 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.