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

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

@@ -1,3 +1,14 @@
+Metadata-Version: 2.5
+Name: bmsdna-devtools
+Version: 0.24.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.24.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.24.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"
@@ -59,8 +60,12 @@ def resolve_board(board: str | None, start: Path | None = None) -> str | None:
     return board or load_bdt_table("ado", start).get("board")
 
 
+def _org_url(remote: AdoRemote) -> str:
+    return f"https://dev.azure.com/{quote(remote.org, safe='')}"
+
+
 def _base_url(remote: AdoRemote) -> str:
-    return f"https://dev.azure.com/{quote(remote.org, safe='')}/{quote(remote.project, safe='')}"
+    return f"{_org_url(remote)}/{quote(remote.project, safe='')}"
 
 
 def get_team_area_path(session: requests.Session, remote: AdoRemote, team: str) -> str:
@@ -204,6 +209,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.
 
@@ -361,8 +399,11 @@ 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 edit_url(remote: AdoRemote, work_item_id: int, project: str | None = None) -> str:
+    """`project` overrides `remote.project` -- needed by an org-wide `search()`, whose results
+    can belong to a different project than the one the command was run in.
+    """
+    return f"{_org_url(remote)}/{quote(project or remote.project, safe='')}/_workitems/edit/{work_item_id}"
 
 
 def _escape_wiql_string(value: str) -> str:
@@ -381,11 +422,13 @@ def build_search_wiql(
     since: str | None = None,
     area_path: str | None = None,
     state: str = "open",
+    org_wide: bool = False,
+    tags: list[str] | None = None,
 ) -> 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.
+    optionally restricted to items changed on/after `since` (an ISO 'YYYY-MM-DD' date), carrying
+    every given tag (ANDed), 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
@@ -396,11 +439,21 @@ def build_search_wiql(
     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).
+
+    `org_wide` drops the `[System.TeamProject] = @project` clause -- `@project` is only valid
+    when the query runs against a project-scoped WIQL endpoint (see `run_wiql`'s `org_wide`),
+    and dropping it is what actually lets the query match work items outside the current project.
+
+    `tags` is a separate filter from `keywords` -- `Contains Words` against Title/Description
+    doesn't match `System.Tags` at all, so a tag search (e.g. every work item tagged
+    'ready4implementation' across the whole org) needs its own `[System.Tags] Contains` clause.
     """
     clauses = [
         f"([System.Title] Contains Words '{_escape_wiql_string(k)}' OR [System.Description] Contains Words '{_escape_wiql_string(k)}')"
         for k in keywords
     ]
+    for tag in tags or []:
+        clauses.append(f"[System.Tags] Contains '{_escape_wiql_string(tag)}'")
     if since:
         clauses.append(f"[System.ChangedDate] >= '{since}T00:00:00Z'")
     if area_path:
@@ -409,13 +462,21 @@ def build_search_wiql(
         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"
+    if not org_wide:
+        clauses.insert(0, "[System.TeamProject] = @project")
+    query = "SELECT [System.Id] FROM WorkItems"
+    if clauses:
+        query += " WHERE " + " AND ".join(clauses)
+    return f"{query} ORDER BY [System.ChangedDate] DESC"
 
 
-def run_wiql(session: requests.Session, remote: AdoRemote, wiql: str, top: int) -> list[int]:
+def run_wiql(session: requests.Session, remote: AdoRemote, wiql: str, top: int, org_wide: bool = False) -> list[int]:
+    """`org_wide` runs the query against the org-level WIQL endpoint (no `/{project}` segment),
+    which Azure DevOps resolves across every project in the org instead of just `remote.project`.
+    """
+    base = _org_url(remote) if org_wide else _base_url(remote)
     r = session.post(
-        f"{_base_url(remote)}/_apis/wit/wiql",
+        f"{base}/_apis/wit/wiql",
         params={"api-version": "7.1", "$top": top},
         json={"query": wiql},
     )
@@ -423,16 +484,23 @@ def run_wiql(session: requests.Session, remote: AdoRemote, wiql: str, top: int)
     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, in the given `ids` order — WIQL only
-    returns ids (not field values), and this batch endpoint doesn't guarantee it echoes them back
-    in the order they were requested, so the caller's WIQL `ORDER BY` isn't preserved otherwise.
+def get_work_items(session: requests.Session, remote: AdoRemote, ids: list[int], org_wide: bool = False) -> list[dict]:
+    """Batch-fetch Title/State (plus TeamProject when `org_wide`) for a set of work item ids, in
+    the given `ids` order — WIQL only returns ids (not field values), and this batch endpoint
+    doesn't guarantee it echoes them back in the order they were requested, so the caller's WIQL
+    `ORDER BY` isn't preserved otherwise.
+
+    `org_wide` fetches via the org-level endpoint (ids from an org-wide `run_wiql` may belong to
+    a project other than `remote.project`) and also asks for `System.TeamProject`, so `search()`
+    can show which project each result came from.
     """
     if not ids:
         return []
+    base = _org_url(remote) if org_wide else _base_url(remote)
+    fields = "System.Title,System.State,System.TeamProject" if org_wide else "System.Title,System.State"
     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"},
+        f"{base}/_apis/wit/workitems",
+        params={"ids": ",".join(map(str, ids)), "fields": fields, "api-version": "7.1"},
     )
     r.raise_for_status()
     by_id = {item["id"]: item for item in r.json()["value"]}
@@ -447,19 +515,31 @@ def search(
     board: str | None = None,
     top: int = 10,
     state: str = "open",
+    org_wide: bool = False,
+    tags: list[str] | None = None,
 ) -> 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.
+    team's subtree instead of the whole project. `tags` is a separate ANDed filter against
+    `System.Tags` (see `build_search_wiql`) -- a plain keyword doesn't match tags.
+
+    `org_wide` searches every project in `remote.org` instead of just `remote.project` --
+    mutually exclusive with `board`, since a team's Area Path only means something within a
+    single project.
     """
+    if org_wide and board:
+        sys.exit("--board can't be combined with --org-wide (a board's Area Path is scoped to a single 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)
+    wiql = build_search_wiql(keywords, since, area_path, state, org_wide=org_wide, tags=tags)
+    ids = run_wiql(session, remote, wiql, top, org_wide=org_wide)
+    items = get_work_items(session, remote, ids, org_wide=org_wide)
     for item in items:
         fields = item["fields"]
-        print(f"#{item['id']} [{fields['System.State']}] {fields['System.Title']}")
-        print(edit_url(remote, item["id"]))
+        project = fields.get("System.TeamProject")
+        prefix = f"[{project}] " if org_wide else ""
+        print(f"{prefix}#{item['id']} [{fields['System.State']}] {fields['System.Title']}")
+        print(edit_url(remote, item["id"], project if org_wide else None))
     if not items:
         print("No matching work items found.")
     return items

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.24.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}")
@@ -450,6 +537,14 @@ def issue_search(
         r"(falls back to \[tool.bdt.github].board), same as `issue create`",
     ),
     limit: int = typer.Option(10, "--limit", help="Max results to return"),
+    org_wide: bool = typer.Option(
+        False,
+        "--org-wide",
+        help="Search every project in the Azure DevOps org, or every repo owned by the GitHub owner, "
+        "instead of just the current one. Can't be combined with --board.",
+    ),
+    label: list[str] = typer.Option([], "--label", help="Only issues carrying this label, ANDed (GitHub only, repeatable)"),
+    tag: list[str] = typer.Option([], "--tag", help="Only work items carrying this tag, ANDed (Azure DevOps only, repeatable)"),
     pat: str | None = typer.Option(
         None,
         "--pat",
@@ -467,12 +562,14 @@ def issue_search(
     remote = current_remote()
     if isinstance(remote, GitHubRemote):
         resolved_board = gh_issue.resolve_board(board)
-        gh_issue.search(require_gh(), remote.owner, remote.repo, keywords or [], since, limit, state, board=resolved_board)
+        gh_issue.search(
+            require_gh(), remote.owner, remote.repo, keywords or [], since, limit, state, board=resolved_board, org_wide=org_wide, labels=label
+        )
     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)
+        ado_issue.search(session, remote, keywords or [], since=since, board=resolved_board, top=limit, state=state, org_wide=org_wide, tags=tag)
 
 
 @issue_app.command("update")
@@ -639,6 +736,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.24.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
@@ -180,18 +215,66 @@ def build_search_query(keywords: list[str], since: str | None) -> str:
 
 
 def search(
-    gh: str, owner: str, repo: str, keywords: list[str], since: str | None, limit: int, state: str = "open", board: str | None = None
+    gh: str,
+    owner: str,
+    repo: str,
+    keywords: list[str],
+    since: str | None,
+    limit: int,
+    state: str = "open",
+    board: str | None = None,
+    org_wide: bool = False,
+    labels: list[str] | None = None,
 ) -> 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. `board`
     scopes results to a GitHub Projects (v2) board (by title or number) -- `gh issue list` has no
     board filter of its own, so this over-fetches a wider raw pool first and filters down to
-    `limit` afterward, client-side.
+    `limit` afterward, client-side. `labels` is ANDed (an issue must carry every given label) --
+    both `gh issue list` and `gh search issues` support a native, repeatable `--label` flag, so
+    it doesn't need folding into `query` as a `label:` qualifier.
+
+    `org_wide` searches every repo `owner` has, via `gh search issues --owner` (GitHub's
+    cross-repo search endpoint) instead of `gh issue list` (always single-repo, scoped by cwd's
+    git remote) -- mutually exclusive with `board`, whose membership is only resolved against
+    `repo`, not every repo under `owner`.
     """
+    if org_wide and board:
+        sys.exit("--board can't be combined with --org-wide (board membership is only resolved for the current repo).")
+
     query = build_search_query(keywords, since)
+    label_args = [arg for label in labels or [] for arg in ("--label", label)]
+
+    if org_wide:
+        # `gh search issues --state` only accepts open/closed (unlike `gh issue list --state`
+        # below, which also takes 'all') -- so 'all' is passed by omitting --state entirely
+        # (`gh search issues`'s own default), rather than forwarding a value it would reject.
+        #
+        # `gh search issues`' `--json state` also returns lowercase 'open'/'closed' (the GitHub
+        # search API's own casing), unlike `gh issue list`'s 'OPEN'/'CLOSED' below (GraphQL enum
+        # casing) -- both are printed as-is, so the two search modes' output differs in casing.
+        state_args = [] if state == "all" else ["--state", state]
+        out = _run_gh(
+            gh,
+            [
+                "search", "issues", query, "--owner", owner, *state_args, *label_args,
+                "--limit", str(limit), "--json", "number,title,url,state,repository",
+            ],
+        )
+        items = json.loads(out) if out else []
+        for item in items:
+            print(f"{item['repository']['nameWithOwner']}#{item['number']} [{item['state']}] {item['title']}")
+            print(item["url"])
+        if not items:
+            print("No matching issues found.")
+        return items
+
     fetch_limit = limit * _BOARD_SEARCH_OVERFETCH if board else limit
-    out = _run_gh(gh, ["issue", "list", "--search", query, "--state", state, "--limit", str(fetch_limit), "--json", "number,title,url,state"])
+    out = _run_gh(
+        gh,
+        ["issue", "list", "--search", query, "--state", state, *label_args, "--limit", str(fetch_limit), "--json", "number,title,url,state"],
+    )
     items = json.loads(out) if out else []
 
     if board:

{bmsdna_devtools-0.22.0 → bmsdna_devtools-0.24.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")