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

{bmsdna_devtools-0.20.0 → bmsdna_devtools-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.20.0
+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
@@ -353,15 +353,48 @@ bdt commit "feat(x): add widget support" file1.py file2.py [--json] [--no-verify
 ```
 
 Stages, commits, and pushes the given files. Pre-flight checks: files
-exist, commit message looks like `type: description` (skip with
-`--skip-message-check`), not on `main`/`master` (skip with `--allow-main`).
-Retries once (re-`git add`) if a pre-commit hook reformats files. Pass
-`--subrepo <dir>` (repeatable) for repos that vendor a submodule (e.g.
-`database`) — files under that prefix are committed/pushed inside the
-submodule first, then the bump is staged in the parent repo.
+exist, commit message follows [Conventional Commits](https://www.conventionalcommits.org)
+(`type(scope): description`, skip with `--skip-message-check`), not on
+`main`/`master` (skip with `--allow-main`). Retries once (re-`git add`) if a
+pre-commit hook reformats files. Pass `--subrepo <dir>` (repeatable) for
+repos that vendor a submodule (e.g. `database`) — files under that prefix
+are committed/pushed inside the submodule first, then the bump is staged in
+the parent repo.
+
+The built-in commit types are `feat`, `fix`, `docs`, `style`, `refactor`,
+`perf`, `test`, `build`, `ci`, `chore`, `revert`. A repo can accept
+additional types on top of those under `[tool.bdt.commit]` in
+`pyproject.toml`:
+
+```toml
+[tool.bdt.commit]
+types = ["sql", "infra"]
+```
+
+Scope (the `(x)` in `feat(x): ...`) is unrestricted by default — any scope,
+or none at all, is accepted. A repo can opt into restricting it to a fixed
+list under the same table:
+
+```toml
+[tool.bdt.commit]
+scopes = ["api", "ui", "db"]
+```
+
+Once configured, a message that *names* a scope must use one from the
+list — but a message with no scope at all is still always accepted; this
+doesn't make a scope mandatory.
+
+If the pushed commit's type is `feat` and the current branch's PR is
+already published (not a draft), it's converted back to draft — a feature
+needs a fresh review pass before CI/merge, not just whatever review
+happened before the commit existed. Run `bdt pr publish` when it's ready
+again. Pass `--target`/`--pat` to resolve the PR on Azure DevOps (GitHub
+always resolves the current branch's PR directly).
 
 Set `IS_BMS_AI_SANDBOX=1` to skip the push step (commit only) — used when
-an AI coding sandbox pushes on its own schedule separately.
+an AI coding sandbox pushes on its own schedule separately. The draft
+conversion above only runs after an actual push, so it's skipped in
+sandbox mode too.
 
 `--json` emits a machine-readable result for AI-agent callers:
 
@@ -369,7 +402,7 @@ an AI coding sandbox pushes on its own schedule separately.
 {
   "success": true, "committed": true, "pushed": true,
   "message": "...", "files": ["..."], "commit_sha": "abc1234",
-  "error": null, "hint": null
+  "error": null, "hint": null, "commit_type": "feat", "commit_scope": "x"
 }
 ```
 

{bmsdna_devtools-0.20.0 → bmsdna_devtools-0.22.0}/README.md

@@ -342,15 +342,48 @@ bdt commit "feat(x): add widget support" file1.py file2.py [--json] [--no-verify
 ```
 
 Stages, commits, and pushes the given files. Pre-flight checks: files
-exist, commit message looks like `type: description` (skip with
-`--skip-message-check`), not on `main`/`master` (skip with `--allow-main`).
-Retries once (re-`git add`) if a pre-commit hook reformats files. Pass
-`--subrepo <dir>` (repeatable) for repos that vendor a submodule (e.g.
-`database`) — files under that prefix are committed/pushed inside the
-submodule first, then the bump is staged in the parent repo.
+exist, commit message follows [Conventional Commits](https://www.conventionalcommits.org)
+(`type(scope): description`, skip with `--skip-message-check`), not on
+`main`/`master` (skip with `--allow-main`). Retries once (re-`git add`) if a
+pre-commit hook reformats files. Pass `--subrepo <dir>` (repeatable) for
+repos that vendor a submodule (e.g. `database`) — files under that prefix
+are committed/pushed inside the submodule first, then the bump is staged in
+the parent repo.
+
+The built-in commit types are `feat`, `fix`, `docs`, `style`, `refactor`,
+`perf`, `test`, `build`, `ci`, `chore`, `revert`. A repo can accept
+additional types on top of those under `[tool.bdt.commit]` in
+`pyproject.toml`:
+
+```toml
+[tool.bdt.commit]
+types = ["sql", "infra"]
+```
+
+Scope (the `(x)` in `feat(x): ...`) is unrestricted by default — any scope,
+or none at all, is accepted. A repo can opt into restricting it to a fixed
+list under the same table:
+
+```toml
+[tool.bdt.commit]
+scopes = ["api", "ui", "db"]
+```
+
+Once configured, a message that *names* a scope must use one from the
+list — but a message with no scope at all is still always accepted; this
+doesn't make a scope mandatory.
+
+If the pushed commit's type is `feat` and the current branch's PR is
+already published (not a draft), it's converted back to draft — a feature
+needs a fresh review pass before CI/merge, not just whatever review
+happened before the commit existed. Run `bdt pr publish` when it's ready
+again. Pass `--target`/`--pat` to resolve the PR on Azure DevOps (GitHub
+always resolves the current branch's PR directly).
 
 Set `IS_BMS_AI_SANDBOX=1` to skip the push step (commit only) — used when
-an AI coding sandbox pushes on its own schedule separately.
+an AI coding sandbox pushes on its own schedule separately. The draft
+conversion above only runs after an actual push, so it's skipped in
+sandbox mode too.
 
 `--json` emits a machine-readable result for AI-agent callers:
 
@@ -358,7 +391,7 @@ an AI coding sandbox pushes on its own schedule separately.
 {
   "success": true, "committed": true, "pushed": true,
   "message": "...", "files": ["..."], "commit_sha": "abc1234",
-  "error": null, "hint": null
+  "error": null, "hint": null, "commit_type": "feat", "commit_scope": "x"
 }
 ```
 

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

@@ -650,6 +650,12 @@ def find_repo_cmd(
     org: str | None = typer.Option(
         None, "--org", envvar=["AZDO_ORG", "BMS_ORG"], help="Azure DevOps org to search when there's no local match"
     ),
+    github_org: str | None = typer.Option(
+        None,
+        "--github-org",
+        envvar=["GITHUB_ORG", "BMS_GITHUB_ORG"],
+        help="GitHub org to search when there's no local match",
+    ),
     yes: bool = typer.Option(False, "--yes", help="Clone a remote-only match without an interactive confirmation prompt"),
     pat: str | None = typer.Option(
         None,
@@ -658,13 +664,15 @@ def find_repo_cmd(
         help="Azure DevOps PAT for cloning over HTTPS (else falls back to `az` login)",
     ),
 ) -> None:
-    """Find a repo by name: locally first, then in an Azure DevOps org if there's no local match -- offering to clone it.
+    """Find a repo by name: locally first, then in an Azure DevOps org and/or a GitHub org if there's
+    no local match -- offering to clone it.
 
     Replaces the `cross-repo-discovery` skill's full `ALL_REPOS.md` org sync with a
     single-name lookup; it reads the same AZDO_WORK_DIR/BMS_WORK_DIR and AZDO_ORG/BMS_ORG
-    env vars that skill used, so switching over needs no reconfiguration.
+    env vars that skill used, so switching over needs no reconfiguration. A GitHub-org match
+    clones into `root/github/<repo>`, by convention.
     """
-    find_repo_mod.run(name, root=root, org=org, yes=yes, pat=pat)
+    find_repo_mod.run(name, root=root, org=org, github_org=github_org, yes=yes, pat=pat)
 
 
 @cleanup_app.command("worktrees")
@@ -738,6 +746,30 @@ def cleanup_worktree(
     )
 
 
+def _draft_feat_pr(target: str, pat: str | None) -> None:
+    """A 'feat' commit landing on an already-published PR forces it back to draft --
+    a feature needs a fresh review pass before CI/merge, not just whatever review
+    happened before this commit existed.
+
+    Best-effort: swallows failures (no PR yet is the common case mid-implementation,
+    plus auth/network hiccups) rather than turning a successful commit+push into a
+    failure over a step that's purely a safety nudge.
+    """
+    try:
+        remote = current_remote()
+        if isinstance(remote, GitHubRemote):
+            converted = gh_pr.set_draft(require_gh())
+        else:
+            session = requests.Session()
+            session.headers.update(auth_header(pat))
+            pr = pr_build.get_pr(session, remote, current_branch(), target)
+            converted = pr_build.set_draft(session, remote, pr)
+    except (Exception, SystemExit):
+        return
+    if converted:
+        print("\n'feat' commit pushed -- PR converted back to draft (needs review before CI runs). Run `bdt pr publish` when ready.")
+
+
 @app.command()
 def commit(
     message: str,
@@ -747,6 +779,13 @@ def commit(
     subrepo: list[str] = typer.Option([], "--subrepo", help="Submodule directory name to split matching files into (repeatable)"),
     skip_message_check: bool = typer.Option(False, "--skip-message-check", help="Don't require a conventional-commit-style message"),
     allow_main: bool = typer.Option(False, "--allow-main", help="Allow committing directly on main/master"),
+    target: str = typer.Option("main", "--target", help="Target branch of the PR to draft on a 'feat' commit (Azure DevOps only)"),
+    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:
     """Stage, commit, and push files, with pre-flight checks and a pre-commit-hook retry."""
     result = commit_mod.commit_and_push(
@@ -757,6 +796,8 @@ def commit(
         require_feature_branch=not allow_main,
         subrepos=subrepo,
     )
+    if result.success and result.pushed and result.extra.get("commit_type") == "feat":
+        _draft_feat_pr(target, pat)
     commit_mod.emit(result, use_json=json_output)
 
 

{bmsdna_devtools-0.20.0 → bmsdna_devtools-0.22.0}/bmsdna/devtools/commit.py

@@ -7,13 +7,67 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
 from dataclasses import dataclass, field
 
+from .bdt_config import load_bdt_table
+
 IS_SANDBOX_ENV_VAR = "IS_BMS_AI_SANDBOX"
 
+# Conventional Commits (https://www.conventionalcommits.org) type prefixes that are
+# always accepted, regardless of what the calling repo configures.
+BUILTIN_COMMIT_TYPES = {"feat", "fix", "docs", "style", "refactor", "perf", "test", "build", "ci", "chore", "revert"}
+
+# `type(scope)!: description` -- scope and the breaking-change `!` are both optional.
+_CONVENTIONAL_COMMIT_RE = re.compile(r"^(?P<type>[a-z]+)(?:\((?P<scope>[^)]+)\))?!?: .+")
+
+
+def allowed_commit_types(start=None) -> set[str]:
+    """`BUILTIN_COMMIT_TYPES` plus whatever a repo adds under `[tool.bdt.commit]`:
+
+        [tool.bdt.commit]
+        types = ["sql", "infra"]
+
+    lets a repo accept custom types (e.g. an "sql" type for a repo organized around
+    database migrations) on top of the standard set, rather than replacing it.
+    """
+    extra = load_bdt_table("commit", start).get("types", [])
+    if not isinstance(extra, list):
+        return set(BUILTIN_COMMIT_TYPES)
+    return BUILTIN_COMMIT_TYPES | {t for t in extra if isinstance(t, str)}
+
+
+def allowed_commit_scopes(start=None) -> set[str]:
+    """`[tool.bdt.commit] scopes = [...]` -- opt-in, like `[tool.bdt.pr.required_labels]`:
+    unconfigured (the default, empty set) means any scope, or no scope at all, is
+    accepted. Configuring it only restricts which scope a message *may* name; a
+    message with no scope at all is still accepted either way -- this doesn't make
+    a scope mandatory.
+    """
+    raw = load_bdt_table("commit", start).get("scopes", [])
+    if not isinstance(raw, list):
+        return set()
+    return {s for s in raw if isinstance(s, str)}
+
+
+def conventional_commit_type(message: str) -> str | None:
+    """The `type` prefix of `message` (e.g. "feat" from "feat(x): add widget"), or
+    None if `message` doesn't follow the `type(scope): description` shape at all.
+    """
+    match = _CONVENTIONAL_COMMIT_RE.match(message)
+    return match.group("type") if match else None
+
+
+def conventional_commit_scope(message: str) -> str | None:
+    """The `scope` of `message` (e.g. "x" from "feat(x): add widget"), or None if
+    `message` doesn't follow the `type(scope): description` shape, or has no scope.
+    """
+    match = _CONVENTIONAL_COMMIT_RE.match(message)
+    return match.group("scope") if match else None
+
 
 def _run(cmd: list[str], cwd: str | None = None) -> subprocess.CompletedProcess:
     try:
@@ -204,12 +258,36 @@ def commit_and_push(
             warnings=warnings,
         )
 
-    msg_ok = not require_message_quality or (len(message) >= 20 and ":" in message)
-    if not check(msg_ok, "commit message quality (len>=20, has colon)"):
+    commit_type = conventional_commit_type(message)
+    allowed_types = allowed_commit_types()
+    msg_ok = not require_message_quality or commit_type in allowed_types
+    if not check(msg_ok, "commit message follows Conventional Commits (type(scope): description)"):
+        return CommitResult(
+            False, False, False, message, files,
+            error=f"Commit message doesn't follow Conventional Commits format 'type(scope): description' "
+            f"(allowed types: {', '.join(sorted(allowed_types))}) — got: {message!r}",
+            hint="Use e.g. 'feat(x): add widget' or 'fix: correct off-by-one'. Add repo-specific types under "
+            "[tool.bdt.commit] types = [...] in pyproject.toml.",
+            warnings=warnings,
+        )
+
+    commit_scope = conventional_commit_scope(message)
+    allowed_scopes = allowed_commit_scopes()
+    # Opt-in: unconfigured `allowed_scopes` means no restriction, and a message with
+    # no scope at all is always fine -- only a *named* scope outside the configured
+    # list is rejected. Matched case-insensitively, same as `pr_labels.missing_label_groups`.
+    scope_ok = (
+        not require_message_quality
+        or not allowed_scopes
+        or commit_scope is None
+        or commit_scope.lower() in {s.lower() for s in allowed_scopes}
+    )
+    if not check(scope_ok, "commit scope is in the allowed list"):
         return CommitResult(
             False, False, False, message, files,
-            error=f"Commit message too short or missing type prefix (e.g. 'feat(x): ...') — got: {message!r}",
-            hint="Use conventional commits format: 'feat(scope): description' or 'fix: description'",
+            error=f"Commit scope {commit_scope!r} isn't in the allowed list configured under "
+            f"[tool.bdt.commit] scopes (allowed: {', '.join(sorted(allowed_scopes))}) — got: {message!r}",
+            hint="Use one of the configured scopes, or omit the scope entirely.",
             warnings=warnings,
         )
 
@@ -266,8 +344,10 @@ def commit_and_push(
     committed = ok
     print("  ✓ committed", flush=True)
 
+    extra = {"commit_type": commit_type, "commit_scope": commit_scope}
+
     if _in_sandbox():
-        return CommitResult(True, committed, False, message, files, commit_sha=_sha(), warnings=warnings)
+        return CommitResult(True, committed, False, message, files, commit_sha=_sha(), warnings=warnings, extra=extra)
 
     pr = _run(["git", "push"])
     if pr.returncode != 0:
@@ -277,10 +357,11 @@ def commit_and_push(
             error=(pr.stdout + pr.stderr).strip(),
             hint="Push rejected. Run `git pull --rebase`, resolve conflicts, then retry.",
             warnings=warnings,
+            extra=extra,
         )
 
     print("  ✓ pushed", flush=True)
-    return CommitResult(True, committed, True, message, files, commit_sha=_sha(), warnings=warnings)
+    return CommitResult(True, committed, True, message, files, commit_sha=_sha(), warnings=warnings, extra=extra)
 
 
 def emit(result: CommitResult, *, use_json: bool) -> None:

{bmsdna_devtools-0.20.0 → bmsdna_devtools-0.22.0}/bmsdna/devtools/find_repo.py

@@ -1,6 +1,7 @@
 """`bdt find-repo <name>`: locate a repo by name, locally first and then in
-an Azure DevOps org, without needing the full `ALL_REPOS.md` org sync that
-the `cross-repo-discovery` skill (bmsuisse/skills) used to require.
+an Azure DevOps org and/or a GitHub org, without needing the full
+`ALL_REPOS.md` org sync that the `cross-repo-discovery` skill
+(bmsuisse/skills) used to require.
 
 Env vars mirror that skill's so switching over needs no reconfiguration:
 - `AZDO_WORK_DIR` / `BMS_WORK_DIR`: local clone root to search (and to clone
@@ -8,6 +9,10 @@ Env vars mirror that skill's so switching over needs no reconfiguration:
   elsewhere.
 - `AZDO_ORG` / `BMS_ORG`: Azure DevOps org to search when no local match is
   found.
+- `GITHUB_ORG` / `BMS_GITHUB_ORG`: GitHub org to search when no local match
+  is found. A match is cloned into `root/github/<repo>` -- GitHub repos
+  aren't split into ADO-style projects, so by convention they all land in
+  one `github` subfolder regardless of which org they came from.
 """
 
 from __future__ import annotations
@@ -16,14 +21,18 @@ import json
 import os
 import subprocess
 import sys
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TypeVar
 
 from .ado_auth import auth_header
-from .cli_tools import require_az
+from .cli_tools import require_az, require_gh
 from .worktree import find_repos
 
+T = TypeVar("T")
+
 
 def work_dir() -> Path:
     env = os.environ.get("AZDO_WORK_DIR") or os.environ.get("BMS_WORK_DIR")
@@ -34,18 +43,21 @@ def work_dir() -> Path:
     return Path("~/projects").expanduser()
 
 
-def find_local(name: str, root: Path) -> list[Path]:
-    """Repos under `root` whose folder name matches `name`, case-insensitively.
-
-    Prefers exact matches; only falls back to substring matches (also
-    case-insensitive) when no exact match exists, so a short/common name
-    doesn't drown in unrelated results.
+def _prefer_exact(items: list[T], name: str, key: Callable[[T], str]) -> list[T]:
+    """Exact (case-insensitive) matches on `key(item)` if there are any, else
+    substring matches -- shared by `find_local`/`find_remote`/`find_github`
+    (and, cross-source, by `run`) so a short/common name doesn't drown in
+    unrelated results.
     """
-    repos = find_repos(root)
-    exact = [r for r in repos if r.name.lower() == name.lower()]
+    exact = [i for i in items if key(i).lower() == name.lower()]
     if exact:
-        return sorted(exact)
-    return sorted(r for r in repos if name.lower() in r.name.lower())
+        return exact
+    return [i for i in items if name.lower() in key(i).lower()]
+
+
+def find_local(name: str, root: Path) -> list[Path]:
+    """Repos under `root` whose folder name matches `name` -- see `_prefer_exact`."""
+    return sorted(_prefer_exact(find_repos(root), name, key=lambda r: r.name))
 
 
 @dataclass(frozen=True)
@@ -53,6 +65,7 @@ class RemoteRepo:
     project: str
     name: str
     remote_url: str
+    source: str = "ado"
 
 
 def _az(az: str, *args: str) -> tuple[bool, str]:
@@ -69,8 +82,7 @@ def _az(az: str, *args: str) -> tuple[bool, str]:
 
 
 def find_remote(az: str, org: str, name: str) -> list[RemoteRepo]:
-    """Search every project in `org` for a repo matching `name`, the same
-    exact-first/substring-fallback rule as `find_local`.
+    """Search every project in `org` for a repo matching `name` -- see `_prefer_exact`.
 
     Azure DevOps has no "search repos by name across the whole org" API, so
     (as the old skill's script did) this lists every project and then every
@@ -95,10 +107,23 @@ def find_remote(az: str, org: str, name: str) -> list[RemoteRepo]:
         for repos in pool.map(repos_for, projects):
             all_repos.extend(repos)
 
-    exact = [r for r in all_repos if r.name.lower() == name.lower()]
-    if exact:
-        return exact
-    return [r for r in all_repos if name.lower() in r.name.lower()]
+    return _prefer_exact(all_repos, name, key=lambda r: r.name)
+
+
+def find_github(gh: str, org: str, name: str) -> list[RemoteRepo]:
+    """Search `org`'s GitHub repos for a match -- see `_prefer_exact`.
+
+    Unlike Azure DevOps, GitHub has a single flat list of repos per org/user
+    (no per-project split), so `gh repo list` covers the whole org in one call.
+    """
+    result = subprocess.run(
+        [gh, "repo", "list", org, "--json", "name,url", "--limit", "1000"], capture_output=True, text=True, check=False
+    )
+    if result.returncode != 0:
+        sys.exit(f"gh repo list failed (try `gh auth login`?):\n{result.stderr.strip()}")
+
+    all_repos = [RemoteRepo(org, r["name"], r["url"], source="github") for r in json.loads(result.stdout)]
+    return _prefer_exact(all_repos, name, key=lambda r: r.name)
 
 
 def clone(remote_url: str, dest: Path, auth: dict[str, str] | None = None) -> subprocess.CompletedProcess:
@@ -120,10 +145,27 @@ def clone(remote_url: str, dest: Path, auth: dict[str, str] | None = None) -> su
         sys.exit("'git' is required for this command but wasn't found on PATH.")
 
 
-def run(name: str, *, root: Path | None, org: str | None, yes: bool, pat: str | None = None) -> None:
+def clone_github(gh: str, full_name: str, dest: Path) -> subprocess.CompletedProcess:
+    """Clone a GitHub repo via `gh repo clone`, so it authenticates the same way
+    `gh repo list` already did.
+
+    Deliberately not `clone()` + a hand-built header: `auth_header` (ADO's Basic-PAT-or-
+    `az`-Bearer-token helper) must never be sent to github.com, and `gh` already knows how
+    to authenticate its own git operations (private repos included).
+    """
+    try:
+        return subprocess.run([gh, "repo", "clone", full_name, str(dest)], check=False)
+    except FileNotFoundError:
+        sys.exit("'gh' is required for this command but wasn't found on PATH.")
+
+
+def run(
+    name: str, *, root: Path | None, org: str | None, github_org: str | None = None, yes: bool, pat: str | None = None
+) -> None:
     """`bdt find-repo <name>`: search `root` (default `work_dir()`) for a local
-    match, then -- if there isn't one -- `org`'s Azure DevOps repos, offering
-    to clone a single remote-only match into `root/<project>/<repo>`.
+    match, then -- if there isn't one -- `org`'s Azure DevOps repos and/or
+    `github_org`'s GitHub repos, offering to clone a single remote-only match
+    into `root/<project>/<repo>` (ADO) or `root/github/<repo>` (GitHub).
     """
     search_root = root or work_dir()
     if not search_root.is_dir():
@@ -138,16 +180,38 @@ def run(name: str, *, root: Path | None, org: str | None, yes: bool, pat: str |
             print(path)
         return
 
-    if not org:
+    if not org and not github_org:
         sys.exit(
             f"No local repo matching '{name}' found under {search_root}. "
-            "Set AZDO_ORG (or BMS_ORG) to also search Azure DevOps, or pass --org."
+            "Set AZDO_ORG (or BMS_ORG) to also search Azure DevOps, GITHUB_ORG (or BMS_GITHUB_ORG) to "
+            "also search GitHub, or pass --org/--github-org."
         )
 
-    az = require_az()
-    remote_matches = find_remote(az, org, name)
+    # Both are independent, network-I/O-bound org searches -- run them concurrently
+    # rather than paying their full latency back-to-back when both are given.
+    remote_matches: list[RemoteRepo] = []
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        searches = []
+        if org:
+            az = require_az()
+            searches.append(pool.submit(find_remote, az, org, name))
+        if github_org:
+            gh = require_gh()
+            searches.append(pool.submit(find_github, gh, github_org, name))
+        for search in searches:
+            remote_matches += search.result()
+
+    # An exact match from one source beats a substring match from the other --
+    # find_remote/find_github already apply exact-first within their own source.
+    remote_matches = _prefer_exact(remote_matches, name, key=lambda r: r.name)
+
     if not remote_matches:
-        sys.exit(f"No repo matching '{name}' found locally under {search_root} or in the '{org}' Azure DevOps org.")
+        searched = []
+        if org:
+            searched.append(f"the '{org}' Azure DevOps org")
+        if github_org:
+            searched.append(f"the '{github_org}' GitHub org")
+        sys.exit(f"No repo matching '{name}' found locally under {search_root} or in " + " or ".join(searched) + ".")
 
     for r in remote_matches:
         print(f"{r.project}/{r.name}  {r.remote_url}")
@@ -156,7 +220,7 @@ def run(name: str, *, root: Path | None, org: str | None, yes: bool, pat: str |
         sys.exit("\nMultiple matches -- narrow the name or clone manually.")
 
     match = remote_matches[0]
-    dest = search_root / match.project / match.name
+    dest = search_root / "github" / match.name if match.source == "github" else search_root / match.project / match.name
     if dest.exists():
         sys.exit(f"{dest} already exists -- remove it or clone manually.")
 
@@ -172,6 +236,9 @@ def run(name: str, *, root: Path | None, org: str | None, yes: bool, pat: str |
             print("Not cloned.")
             return
 
-    result = clone(match.remote_url, dest, auth_header(pat))
+    if match.source == "github":
+        result = clone_github(require_gh(), f"{match.project}/{match.name}", dest)
+    else:
+        result = clone(match.remote_url, dest, auth_header(pat))
     if result.returncode != 0:
         raise SystemExit(result.returncode)

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

@@ -499,6 +499,22 @@ def publish(gh: str) -> None:
     print("\nRun `bdt pr status --wait` to watch the PR's CI.")
 
 
+def set_draft(gh: str) -> bool:
+    """Convert the current branch's ready PR back to a draft (`gh pr ready --undo`).
+
+    Returns True if it was just converted, False if it was already a draft --
+    a caller announcing "converted to draft" shouldn't do so for a PR that
+    already was one.
+    """
+    pr = get_pr(gh)
+    if pr.get("isDraft"):
+        return False
+    r = _run([gh, "pr", "ready", "--undo"], capture_output=True, encoding="utf-8")
+    if r.returncode != 0:
+        sys.exit((r.stderr or r.stdout).strip() or "`gh pr ready --undo` failed")
+    return True
+
+
 def _git(args: list[str], env: dict[str, str] | None = None, *, timeout: float = CLI_TIMEOUT_SECS) -> str:
     r = _run(["git", *args], capture_output=True, encoding="utf-8", env=env, timeout=timeout)
     if r.returncode != 0:

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

@@ -313,6 +313,19 @@ def publish(session: requests.Session, remote: AdoRemote, pr: dict) -> None:
     print("\nRun `bdt pr status --wait` to watch the PR's CI.")
 
 
+def set_draft(session: requests.Session, remote: AdoRemote, pr: dict) -> bool:
+    """Convert a ready PR back to a draft (sets isDraft).
+
+    Returns True if it was just converted, False if it was already a draft --
+    a caller announcing "converted to draft" shouldn't do so for a PR that
+    already was one.
+    """
+    if pr.get("isDraft"):
+        return False
+    _patch_pr(session, remote, pr["pullRequestId"], {"isDraft": True})
+    return True
+
+
 def add_comment(session: requests.Session, remote: AdoRemote, pr_id: int, content: str) -> None:
     """Post a new top-level comment thread on the PR."""
     r = session.post(

{bmsdna_devtools-0.20.0 → bmsdna_devtools-0.22.0}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["bmsdna"]
 
 [project]
 name = "bmsdna-devtools"
-version = "0.20.0"
+version = "0.22.0"
 description = "Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects"
 readme = "README.md"
 requires-python = ">=3.14"  # pgdevkit>=0.7.1 requires 3.14; was >=3.11 before adding it as a dependency