bmsdna-devtools 0.7.0__tar.gz → 0.9.0__tar.gz

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.7.0
+Version: 0.9.0
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.32.0

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.0}/bmsdna/devtools/ado_issue.py

@@ -157,6 +157,29 @@ def update_work_item(
     return r.json()
 
 
+def get_work_item_type(session: requests.Session, remote: AdoRemote, work_item_id: int) -> str:
+    r = session.get(
+        f"{_base_url(remote)}/_apis/wit/workitems/{work_item_id}",
+        params={"fields": "System.WorkItemType", "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()
+    return r.json()["fields"]["System.WorkItemType"]
+
+
+def get_valid_states(session: requests.Session, remote: AdoRemote, work_item_type: str) -> list[str]:
+    """The state names defined for `work_item_type` by this project's process template —
+    state names (and which ones are terminal) are per-type, per-template, not a fixed set.
+    """
+    r = session.get(
+        f"{_base_url(remote)}/_apis/wit/workitemtypes/{quote(work_item_type, safe='')}/states",
+        params={"api-version": "7.1"},
+    )
+    r.raise_for_status()
+    return [s["name"] for s in r.json()["value"]]
+
+
 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.
 
@@ -264,6 +287,110 @@ 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, 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.
+    """
+    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()
+    by_id = {item["id"]: item for item in r.json()["value"]}
+    return [by_id[i] for i in ids if i in by_id]
+
+
+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,
@@ -298,13 +425,45 @@ def update(
     board: str | None = None,
     tags: list[str] | None = None,
     state: str | None = None,
-) -> dict:
+) -> dict | None:
     """Update a work item's fields. Unlike `create`, `board` is only resolved (and the Area Path only
     touched) when explicitly given — it never falls back to `[tool.bdt.ado].board`, so an unrelated
     field update (e.g. just `--title`) can't silently move the item to a different team's board.
+
+    If `state` isn't one of this work item's type's valid states (state names, and which ones are
+    terminal, are defined per work item type per process template — e.g. a Basic-process Issue has
+    'Done' but no 'Closed'), the state is left unchanged and a comment records the exact state that
+    was requested instead of the update failing or silently doing nothing.
     """
     area_path = get_team_area_path(session, remote, board) if board else None
-    work_item = update_work_item(session, remote, work_item_id, title, description, area_path, tags, state)
+    applied_state = state
+    if state is not None:
+        work_item_type = get_work_item_type(session, remote, work_item_id)
+        valid_states = get_valid_states(session, remote, work_item_type)
+        # Azure DevOps state values are case-sensitive, so a case-insensitive match ('closed' for
+        # a project whose actual state is 'Closed') must still PATCH the canonical casing, not the
+        # caller's — otherwise the update fails (or silently sets a technically-invalid value)
+        # despite the validation above having found a match.
+        canonical_state = next((s for s in valid_states if state.lower() == s.lower()), None)
+        if canonical_state is not None:
+            applied_state = canonical_state
+        else:
+            add_comment(
+                session,
+                remote,
+                work_item_id,
+                f"Requested state change to '{state}', which isn't a valid state for a "
+                f"'{work_item_type}' here (valid states: {', '.join(valid_states)}) — left unchanged.",
+            )
+            applied_state = None
+
+    if title is None and description is None and area_path is None and tags is None and applied_state is None:
+        if state is not None:
+            print(f"Work item #{work_item_id}: '{state}' isn't a valid state here — noted in a comment.")
+            return None
+        sys.exit("Nothing to update — provide at least one of --title, --description, --board, --tag, --state.")
+
+    work_item = update_work_item(session, remote, work_item_id, title, description, area_path, tags, applied_state)
     print(f"Updated work item #{work_item_id}")
     return work_item
 

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.0}/bmsdna/devtools/cli.py

@@ -4,6 +4,7 @@ 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
 
@@ -325,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)"),
@@ -337,7 +378,14 @@ def issue_update(
         r"this is only applied when explicitly given here — it does not fall back to \[tool.bdt.ado].board, "
         "so an unrelated field update can't silently move the item onto a different board.",
     ),
-    state: str | None = typer.Option(None, "--state", help="New work item state, e.g. Active, Resolved, Closed (Azure DevOps only)"),
+    state: str | None = typer.Option(
+        None,
+        "--state",
+        help="New state. Both backends understand 'Open', 'Closed'/'Done' (closes as completed), and "
+        "'Removed'/'Not Planned' (closes as not planned); other values (e.g. Active, Resolved) only "
+        "apply where that exact state name exists for the work item's type — elsewhere the state is "
+        "left unchanged and a comment records what was requested.",
+    ),
     tag: list[str] | None = typer.Option(None, "--tag", help="Replaces all tags (Azure DevOps only, repeatable); omit to leave unchanged"),
     label: list[str] | None = typer.Option(None, "--label", help="Label to add (GitHub only, repeatable)"),
     remove_label: list[str] | None = typer.Option(None, "--remove-label", help="Label to remove (GitHub only, repeatable)"),
@@ -351,7 +399,7 @@ def issue_update(
     """Update an issue / work item's fields (Azure DevOps or GitHub, auto-detected)."""
     remote = current_remote()
     if isinstance(remote, GitHubRemote):
-        gh_issue.update(require_gh(), number, title, description, label, remove_label)
+        gh_issue.update(require_gh(), number, title, description, label, remove_label, state)
     else:
         session = requests.Session()
         session.headers.update(auth_header(pat))

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.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,68 @@ 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
+
+
+_DONE_STATE_NAMES = ("closed", "done", "completed")
+_REMOVED_STATE_NAMES = ("removed", "not planned", "not_planned", "wontfix", "won't fix")
+_OPEN_STATE_NAMES = ("open", "reopened", "reopen")
+
+
+def _set_state(gh: str, number: int, state: str) -> None:
+    """GitHub issues only have two states (open/closed) plus, when closed, a `state_reason` of
+    'completed' or 'not planned' — no per-process-template state names like Azure DevOps. Map the
+    common terminal-state spellings onto that: 'Closed'/'Done'/'Completed' close as completed
+    (GitHub's "done" concept); 'Removed'/'Not Planned'/'Wontfix' close as not planned; 'Open'/
+    'Reopened' reopens. Anything else has no GitHub equivalent — leave the issue's state
+    unchanged and comment with the exact state that was requested, so it isn't silently dropped.
+    """
+    normalized = state.strip().lower()
+    if normalized in _DONE_STATE_NAMES:
+        _run_gh(gh, ["issue", "close", str(number), "--reason", "completed"])
+    elif normalized in _REMOVED_STATE_NAMES:
+        _run_gh(gh, ["issue", "close", str(number), "--reason", "not planned"])
+    elif normalized in _OPEN_STATE_NAMES:
+        _run_gh(gh, ["issue", "reopen", str(number)])
+    else:
+        _run_gh(
+            gh,
+            [
+                "issue",
+                "comment",
+                str(number),
+                "--body",
+                f"Requested state change to '{state}', which isn't a valid GitHub issue state — left unchanged.",
+            ],
+        )
+
+
 def update(
     gh: str,
     number: int,
@@ -88,6 +151,7 @@ def update(
     body: str | None = None,
     add_labels: list[str] | None = None,
     remove_labels: list[str] | None = None,
+    state: str | None = None,
 ) -> None:
     args = ["issue", "edit", str(number)]
     if title is not None:
@@ -98,10 +162,13 @@ def update(
         args += ["--add-label", label]
     for label in remove_labels or []:
         args += ["--remove-label", label]
-    if len(args) == 3:
-        sys.exit("Nothing to update — provide at least one of --title, --description, --label, --remove-label.")
+    if len(args) == 3 and state is None:
+        sys.exit("Nothing to update — provide at least one of --title, --description, --label, --remove-label, --state.")
 
-    _run_gh(gh, args)
+    if len(args) > 3:
+        _run_gh(gh, args)
+    if state is not None:
+        _set_state(gh, number, state)
     print(f"Updated issue #{number}")
 
 

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.0}/pyproject.toml

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

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.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.7.0 → bmsdna_devtools-0.9.0}/tests/test_ado_issue_flow.py

@@ -8,11 +8,14 @@ from __future__ import annotations
 
 from unittest.mock import MagicMock
 
+import pytest
+
 from bmsdna.devtools.ado_issue import (
     comment_with_screenshots,
     create,
     delete,
     delete_comment,
+    search,
     update,
     update_comment,
 )
@@ -34,7 +37,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 +48,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 +192,147 @@ 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_preserves_wiql_order_when_batch_fetch_returns_a_different_order() -> None:
+    # The batch "list work items by id" endpoint doesn't guarantee it echoes ids back in the
+    # order they were requested — WIQL's ORDER BY [System.ChangedDate] DESC must still win.
+    session = make_session(
+        get_map={
+            "/_apis/wit/workitems": {
+                "value": [
+                    {"id": 50, "fields": {"System.Title": "Oldest match", "System.State": "Active"}},
+                    {"id": 102, "fields": {"System.Title": "Newest match", "System.State": "Active"}},
+                    {"id": 99, "fields": {"System.Title": "Middle match", "System.State": "Active"}},
+                ]
+            }
+        },
+        wiql_ids=[102, 99, 50],
+    )
+
+    results = search(session, REMOTE, ["auth"])
+
+    assert [item["id"] for item in results] == [102, 99, 50]
+
+
+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
+
+
+def test_update_with_valid_state_includes_it_in_the_patch() -> None:
+    session = make_session(
+        get_map={
+            "/_apis/wit/workitems/42": {"fields": {"System.WorkItemType": "Bug"}},
+            "/_apis/wit/workitemtypes/Bug/states": {"value": [{"name": "New"}, {"name": "Active"}, {"name": "Closed"}]},
+        }
+    )
+
+    update(session, REMOTE, 42, state="Closed")
+
+    ops = session.patch.call_args.kwargs["json"]
+    assert {"op": "add", "path": "/fields/System.State", "value": "Closed"} in ops
+
+
+def test_update_state_uses_canonical_casing_from_valid_states() -> None:
+    session = make_session(
+        get_map={
+            "/_apis/wit/workitems/42": {"fields": {"System.WorkItemType": "Bug"}},
+            "/_apis/wit/workitemtypes/Bug/states": {"value": [{"name": "New"}, {"name": "Closed"}]},
+        }
+    )
+
+    update(session, REMOTE, 42, state="closed")  # lowercase — doesn't match ADO's 'Closed' exactly
+
+    ops = session.patch.call_args.kwargs["json"]
+    assert {"op": "add", "path": "/fields/System.State", "value": "Closed"} in ops
+
+
+def test_update_with_invalid_state_comments_instead_of_failing() -> None:
+    session = make_session(
+        get_map={
+            "/_apis/wit/workitems/42": {"fields": {"System.WorkItemType": "Bug"}},
+            "/_apis/wit/workitemtypes/Bug/states": {"value": [{"name": "New"}, {"name": "Active"}, {"name": "Closed"}]},
+        }
+    )
+
+    result = update(session, REMOTE, 42, state="Done")
+
+    assert result is None
+    session.patch.assert_not_called()
+    comment_url, comment_kwargs = session.post.call_args.args[0], session.post.call_args.kwargs
+    assert comment_url == "https://dev.azure.com/myorg/MyProj/_apis/wit/workItems/42/comments"
+    assert "'Done'" in comment_kwargs["json"]["text"]
+    assert "Bug" in comment_kwargs["json"]["text"]
+
+
+def test_update_with_invalid_state_still_patches_other_given_fields() -> None:
+    session = make_session(
+        get_map={
+            "/_apis/wit/workitems/42": {"fields": {"System.WorkItemType": "Bug"}},
+            "/_apis/wit/workitemtypes/Bug/states": {"value": [{"name": "New"}]},
+        }
+    )
+
+    update(session, REMOTE, 42, title="New title", state="Done")
+
+    ops = session.patch.call_args.kwargs["json"]
+    assert ops == [{"op": "add", "path": "/fields/System.Title", "value": "New title"}]
+
+
+def test_update_with_nothing_given_still_errors() -> None:
+    session = make_session()
+
+    with pytest.raises(SystemExit):
+        update(session, REMOTE, 42)

bmsdna_devtools-0.9.0/tests/test_gh_issue.py

@@ -0,0 +1,112 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from bmsdna.devtools.gh_issue import build_search_query, parse_comment_id, parse_issue_number, search, update
+
+
+@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"
+
+
+def _run_update_capturing_commands(monkeypatch, **update_kwargs) -> list[list[str]]:
+    captured_cmds: list[list[str]] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmds.append(cmd)
+        return MagicMock(returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_issue.subprocess.run", fake_run)
+    update("gh", 42, **update_kwargs)
+    return captured_cmds
+
+
+@pytest.mark.parametrize("state", ["Closed", "Done", "completed"])
+def test_update_closes_as_completed_for_done_states(monkeypatch, state: str) -> None:
+    cmds = _run_update_capturing_commands(monkeypatch, state=state)
+    assert cmds == [["gh", "issue", "close", "42", "--reason", "completed"]]
+
+
+@pytest.mark.parametrize("state", ["Removed", "Not Planned", "wontfix"])
+def test_update_closes_as_not_planned_for_removed_states(monkeypatch, state: str) -> None:
+    cmds = _run_update_capturing_commands(monkeypatch, state=state)
+    assert cmds == [["gh", "issue", "close", "42", "--reason", "not planned"]]
+
+
+def test_update_reopens_for_open_state(monkeypatch) -> None:
+    cmds = _run_update_capturing_commands(monkeypatch, state="Open")
+    assert cmds == [["gh", "issue", "reopen", "42"]]
+
+
+def test_update_comments_exact_state_when_unsupported(monkeypatch) -> None:
+    cmds = _run_update_capturing_commands(monkeypatch, state="Active")
+    assert cmds == [["gh", "issue", "comment", "42", "--body", "Requested state change to 'Active', which isn't a valid GitHub issue state — left unchanged."]]
+
+
+def test_update_errors_with_nothing_to_do(monkeypatch) -> None:
+    monkeypatch.setattr("bmsdna.devtools.gh_issue.subprocess.run", MagicMock())
+    with pytest.raises(SystemExit):
+        update("gh", 42)

{bmsdna_devtools-0.7.0 → bmsdna_devtools-0.9.0}/uv.lock

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

bmsdna_devtools-0.7.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