Slang Pr Create

Slang PR Create

Create a focused GitHub pull request from the current branch. Default to the repository configured by the local origin remote; if the user specifies a repo or remote, use that target instead. Use this skill for Slang-related requests to create, open, publish, or prepare a PR. It can target any GitHub repository or git remote, defaulting to local origin; requests targeting a shader-slang/* repository should use this skill even when the user does not explicitly invoke /slang-pr-create.

Usage: /slang-pr-create [--repo owner/repo-or-url-or-remote] [--no-draft] [--wsl]

PRs targeting shader-slang/* are created as drafts by default. PRs targeting other repositories are created ready for review. Use --no-draft only when a shader-slang/* PR should be ready for review immediately. Created PRs are assigned to @me by default. Only pass labels that are present in the target repository. If the target repository has a CoPilot label, add it when creating the PR. After creating a draft PR, request CodeRabbit review by commenting @coderabbitai review.

--wsl means "use native WSL tools" when running inside WSL. Without it, require Windows-hosted .exe tools such as gh.exe. If they are missing, stop and tell the user to install the Windows tools or rerun with --wsl.

Preconditions

• GitHub CLI (gh or gh.exe) is installed and authenticated.
• The current directory is a git worktree for the branch to publish.
• The branch has committed changes intended for the PR.

Select Tools

Before running any git or gh command, detect WSL and choose tools. When the agent is running under WSL, require .exe tools by default because GitHub authentication and browser login are often configured on the Windows side. Do not silently fall back to native WSL tools in this mode. If the user passes --wsl, explicitly use native WSL tools instead.

ARGS="${ARGUMENTS:-}"
USE_WSL_TOOLS=false
DRAFT=true
if printf '%s\n' "$ARGS" | grep -Eq '(^|[[:space:]])--wsl([[:space:]]|$)'; then
  USE_WSL_TOOLS=true
  ARGS="$(printf '%s\n' "$ARGS" | sed -E 's/(^|[[:space:]])--wsl([[:space:]]|$)/ /; s/^[[:space:]]+//; s/[[:space:]]+$//')"
fi
if printf '%s\n' "$ARGS" | grep -Eq '(^|[[:space:]])--no-draft([[:space:]]|$)'; then
  DRAFT=false
  ARGS="$(printf '%s\n' "$ARGS" | sed -E 's/(^|[[:space:]])--no-draft([[:space:]]|$)/ /; s/^[[:space:]]+//; s/[[:space:]]+$//')"
fi

is_wsl() {
  [ -n "${WSL_DISTRO_NAME:-}" ] || grep -qi microsoft /proc/version 2>/dev/null
}

choose_tool() {
  tool="$1"
  if is_wsl && [ "$USE_WSL_TOOLS" = false ]; then
    if command -v "${tool}.exe" >/dev/null 2>&1; then
      printf '%s.exe\n' "$tool"
      return 0
    fi
    printf 'Missing Windows-hosted tool: %s.exe\n' "$tool" >&2
    printf 'Install it on Windows or rerun with --wsl to use native WSL %s.\n' "$tool" >&2
    return 1
  fi

  if command -v "$tool" >/dev/null 2>&1; then
    printf '%s\n' "$tool"
    return 0
  fi
  printf 'Missing native tool: %s\n' "$tool" >&2
  return 1
}

GIT="$(choose_tool git)" || exit 1
GH="$(choose_tool gh)" || exit 1

Use $GIT and $GH in all subsequent shell examples. Strip \r from command substitution output because Windows .exe tools may print CRLF:

clean_line() { tr -d '\r'; }

Write the PR body outside the tracked worktree, then pass a Windows path from wslpath -w when $GH ends in .exe:

BODY_FILE="$("$GIT" rev-parse --git-path slang-pr-body.md | clean_line)"
if is_wsl && command -v wslpath >/dev/null 2>&1; then
  case "$BODY_FILE" in
    *\\*|[A-Za-z]:*) BODY_FILE="$(wslpath -u "$BODY_FILE")" ;;
  esac
fi
BODY_FILE_ARG="$BODY_FILE"
if is_wsl && [ "${GH%.exe}" != "$GH" ] && command -v wslpath >/dev/null 2>&1; then
  BODY_FILE_ARG="$(wslpath -w "$BODY_FILE")"
fi

Resolve Inputs

Use the repository from the user request when provided. Accept --repo owner/repo, --repo https://github.com/owner/repo, --repo <git-remote>, a bare positional owner/repo, a GitHub URL, or a bare positional git remote name such as origin or upstream.

If a bare token with no slash matches git remote, treat that remote's URL as the target repository and prefer that same remote as the push remote. If the bare token is upstream but no upstream git remote exists, infer shader-slang/<repo-name> from the local origin repository name, so forks of repositories such as shader-slang/slangpy target the matching upstream repository. If omitted, behave as if origin was provided. Do not default to a specific shader-slang/* repository when any explicit repository or remote argument was provided; fail instead if it cannot be resolved.

# Parse the remaining skill arguments after `--wsl` and `--no-draft` are removed.
# shellcheck disable=SC2086
set -- $ARGS
TARGET_ARG=""
while [ $# -gt 0 ]; do
  case "$1" in
    --repo)
      shift
      if [ $# -eq 0 ] || [ -z "${1:-}" ] || [[ "${1:-}" == --* ]]; then
        echo "Missing value for --repo"
        exit 1
      fi
      TARGET_ARG="${1:-}"
      ;;
    --repo=*)
      if [ -z "${1#--repo=}" ]; then
        echo "Missing value for --repo"
        exit 1
      fi
      TARGET_ARG="${1#--repo=}"
      ;;
    *)
      if [ -z "$TARGET_ARG" ]; then
        TARGET_ARG="$1"
      fi
      ;;
  esac
  shift
done
if [ -z "$TARGET_ARG" ]; then
  TARGET_ARG="origin"
fi

TARGET_REMOTE=""
if [[ "$TARGET_ARG" != */* && "$TARGET_ARG" != http://* && "$TARGET_ARG" != https://* && "$TARGET_ARG" != git@github.com:* ]]; then
  if "$GIT" remote get-url "$TARGET_ARG" >/dev/null 2>&1; then
    TARGET_REMOTE="$TARGET_ARG"
    TARGET_URL="$("$GIT" remote get-url "$TARGET_REMOTE" | clean_line)"
    REPO="$TARGET_URL"
  elif [ "$TARGET_ARG" = "upstream" ]; then
    ORIGIN_URL="$("$GIT" remote get-url origin 2>/dev/null | clean_line || true)"
    if [ -z "$ORIGIN_URL" ]; then
      echo "Could not infer shader-slang upstream target because the origin remote is missing"
      exit 1
    fi
    ORIGIN_REPO_NAME="${ORIGIN_URL%/}"
    ORIGIN_REPO_NAME="${ORIGIN_REPO_NAME##*/}"
    ORIGIN_REPO_NAME="${ORIGIN_REPO_NAME%.git}"
    if [ -z "$ORIGIN_REPO_NAME" ]; then
      echo "Could not infer shader-slang upstream target from origin URL: $ORIGIN_URL"
      exit 1
    fi
    REPO="shader-slang/$ORIGIN_REPO_NAME"
  else
    echo "Could not resolve requested or default PR target as a GitHub repo or git remote: $TARGET_ARG"
    exit 1
  fi
else
  REPO="$TARGET_ARG"
fi
REPO="$("$GH" repo view "$REPO" --json nameWithOwner --jq .nameWithOwner | clean_line)"

Always query the target repository's default branch instead of assuming master or main:

REPO_NAME_WITH_OWNER="$("$GH" repo view "$REPO" --json nameWithOwner --jq .nameWithOwner | clean_line)"
BASE="$("$GH" repo view "$REPO" --json defaultBranchRef --jq .defaultBranchRef.name | clean_line)"
BRANCH="$("$GIT" branch --show-current | clean_line)"
case "$REPO_NAME_WITH_OWNER" in
  shader-slang/*)
    ;;
  *)
    DRAFT=false
    ;;
esac

Try to determine the issue references that the PR is intended to fix before creating the PR. Closing references should use Fixes #123 for same-repository issues and Fixes owner/repo#123 for cross-repository issues.

First ask GitHub whether the current branch is already linked to one or more issue development branches. gh issue develop --list works once an issue number is known; to discover issues from the current branch, query the linked branch metadata:

OWNER="${REPO_NAME_WITH_OWNER%/*}"
NAME="${REPO_NAME_WITH_OWNER#*/}"
mapfile -t LINKED_ISSUE_REFS < <("$GH" api graphql --paginate --slurp \
  -F owner="$OWNER" \
  -F name="$NAME" \
  -f query='query($owner: String!, $name: String!, $endCursor: String) {
    repository(owner: $owner, name: $name) {
      issues(first: 100, states: OPEN, after: $endCursor) {
        nodes {
          number
          repository { nameWithOwner }
          linkedBranches(first: 20) {
            nodes { ref { name repository { nameWithOwner } } }
          }
        }
        pageInfo { hasNextPage endCursor }
      }
    }
  }' | jq -r --arg branch "$BRANCH" '
    [.[].data.repository.issues.nodes[]
      | select(any(.linkedBranches.nodes[]?; .ref.name == $branch))
      | "\(.repository.nameWithOwner)#\(.number)"]
    | unique
    | .[]
  ')

This uses gh api --slurp with --paginate so gh wraps paginated GraphQL responses in one JSON array before jq processes them.

If jq is unavailable, run the same GraphQL query and inspect the JSON output manually for linkedBranches entries whose ref.name equals $BRANCH.

If this returns one or more issue references, include all of the references that the PR fixes. If it returns none, use any full issue references explicitly provided by the user. If only issue numbers are provided or inferred from clear local evidence such as the branch name, commit message, or existing task context, combine each issue number with $REPO_NAME_WITH_OWNER. If any issue belongs to a different repository, use that issue's owner/repo instead.

Do not stop PR creation only because issue references cannot be inferred. Use only confidently determined issue references, skip ambiguous or unavailable ones, and omit closing lines entirely if no issue reference is known.

PowerShell / gh.exe equivalent:

This snippet assumes $repo has already been resolved and normalized using the same input-resolution rules described above. Do not use the placeholder value literally.

$repo = "<resolved-target-repo>"
$repoNameWithOwner = gh.exe repo view $repo --json nameWithOwner --jq ".nameWithOwner"
$base = gh.exe repo view $repo --json defaultBranchRef --jq ".defaultBranchRef.name"
$branch = git branch --show-current
$owner, $name = $repoNameWithOwner -split '/', 2
$query = @'
query($owner: String!, $name: String!, $endCursor: String) {
  repository(owner: $owner, name: $name) {
    issues(first: 100, states: OPEN, after: $endCursor) {
      nodes {
        number
        repository { nameWithOwner }
        linkedBranches(first: 20) {
          nodes { ref { name repository { nameWithOwner } } }
        }
      }
      pageInfo { hasNextPage endCursor }
    }
  }
}
'@
$pages = gh.exe api graphql --paginate --slurp `
  -F "owner=$owner" `
  -F "name=$name" `
  -f "query=$query" | ConvertFrom-Json
$linkedIssueRefs = @()
foreach ($page in $pages) {
  foreach ($issue in $page.data.repository.issues.nodes) {
    if ($issue.linkedBranches.nodes | Where-Object { $_.ref -and $_.ref.name -eq $branch }) {
      $linkedIssueRefs += "$($issue.repository.nameWithOwner)#$($issue.number)"
    }
  }
}
$linkedIssueRefs = $linkedIssueRefs | Sort-Object -Unique

Required Safety Check

Before pushing or creating a PR, run:

"$GIT" status --short

If there is any output, stop and clarify with the user before continuing. Show the changed and untracked files, then ask how to proceed. Do not commit, stash, discard, push, or create the PR until the user chooses.

Offer these options:

1. Commit all changes: ask for a commit message, then run "$GIT" add -A && "$GIT" commit -m "<message>".
2. Commit only staged changes: only if staged files exist; ask for a commit message, then run "$GIT" commit -m "<message>".
3. Stash changes: run "$GIT" stash push -m "slang-pr-create stash" and create the PR from the current committed HEAD.
4. Abort: stop so the user can handle the worktree manually.

Create The PR

Check basic state:

"$GH" auth status
"$GIT" status --short
"$GIT" remote -v
"$GIT" branch --show-current
"$GH" repo view "$REPO" --json nameWithOwner,defaultBranchRef,url

Branch Naming

Preserve the current branch whenever possible. Do not rename the current branch or move the commits onto a new branch when the current branch is already a topic branch (any branch whose name is not the target default branch). In that case keep BRANCH as-is and create the PR from it.

Only create a new branch when the current branch is the default branch, i.e. BRANCH is empty (detached HEAD) or BRANCH equals BASE. Never open a PR whose head is the default branch. When this happens, choose a new branch name that reflects what the committed changes do (for example, derived from the primary commit subject), switch to it, and create the PR from that branch:

if [ -z "$BRANCH" ] || [ "$BRANCH" = "$BASE" ]; then
  # On the default branch (or detached HEAD): create a topic branch that
  # describes the change. Derive a slug from the latest commit subject and
  # sanitize it into a valid branch name.
  COMMIT_SUBJECT="$("$GIT" log -1 --pretty=%s | clean_line)"
  NEW_BRANCH="$(printf '%s' "$COMMIT_SUBJECT" \
    | tr '[:upper:]' '[:lower:]' \
    | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//' \
    | cut -c1-50 \
    | sed -E 's/-+$//')"
  [ -z "$NEW_BRANCH" ] && NEW_BRANCH="slang-pr-$("$GIT" rev-parse --short HEAD | clean_line)"

  # Avoid clobbering an existing local branch of the same name.
  CANDIDATE="$NEW_BRANCH"
  suffix=1
  while "$GIT" show-ref --verify --quiet "refs/heads/$CANDIDATE"; do
    suffix=$((suffix + 1))
    CANDIDATE="${NEW_BRANCH}-${suffix}"
  done
  NEW_BRANCH="$CANDIDATE"

  "$GIT" switch -c "$NEW_BRANCH" || exit 1
  BRANCH="$NEW_BRANCH"
  printf 'Was on default branch %s; created topic branch %s for the PR.\n' "$BASE" "$BRANCH" >&2
fi

Prefer a descriptive slug, but you may instead ask the user for a branch name when the change spans many commits or no single commit subject captures it. After this step BRANCH always names a topic branch distinct from BASE.

Fetch the target default branch and verify the branch has commits for the PR:

"$GIT" fetch "https://github.com/$REPO.git" "$BASE"
"$GIT" log --oneline FETCH_HEAD..HEAD

If there are no commits ahead of the target default branch, stop and report that there is nothing committed to open as a PR.

Push the branch if needed. Track the remote branch that was actually published and use it later for gh pr create:

If the same-name push is rejected because the remote branch already exists or has diverged, push HEAD to a new remote branch name and create the PR from that new branch. For authentication, permission, or missing-remote failures, stop instead of trying a new branch name.

if [ -n "${TARGET_REMOTE:-}" ]; then
  PUSH_REMOTE="$TARGET_REMOTE"
else
  PUSH_REMOTE="$("$GIT" config --get "branch.$BRANCH.remote" | clean_line || true)"
fi
if [ -z "$PUSH_REMOTE" ]; then
  while IFS= read -r remote; do
    [ -z "$remote" ] && continue
    if "$GIT" remote get-url --push "$remote" >/dev/null 2>&1; then
      PUSH_REMOTE="$remote"
      break
    fi
  done < <("$GIT" remote | clean_line)
fi
if [ -z "$PUSH_REMOTE" ]; then
  echo "Could not determine a push remote. Ask before adding a remote or changing push destinations."
  exit 1
fi

PUBLISHED_BRANCH="$BRANCH"
PR_HEAD="$PUBLISHED_BRANCH"
PUSH_LOG="$(mktemp "${TMPDIR:-/tmp}/slang-pr-push.XXXXXX")"
trap 'rm -f "$PUSH_LOG"' EXIT
if ! "$GIT" push -u "$PUSH_REMOTE" "HEAD:refs/heads/$PUBLISHED_BRANCH" 2>"$PUSH_LOG"; then
  PUSH_OUTPUT="$(clean_line < "$PUSH_LOG")"
  if printf '%s\n' "$PUSH_OUTPUT" | grep -Eiq 'non-fast-forward|fetch first|stale info|already exists|remote contains work that you do not have'; then
    SHORT_HEAD="$("$GIT" rev-parse --short HEAD | clean_line)"
    PUBLISHED_BRANCH="${BRANCH}-${SHORT_HEAD}"
    suffix=1
    while "$GIT" ls-remote --exit-code --heads "$PUSH_REMOTE" "$PUBLISHED_BRANCH" >/dev/null 2>&1; do
      suffix=$((suffix + 1))
      PUBLISHED_BRANCH="${BRANCH}-${SHORT_HEAD}-${suffix}"
    done
    printf '%s\n' "$PUSH_OUTPUT" >&2
    printf 'Push to %s/%s was rejected; retrying as %s/%s.\n' "$PUSH_REMOTE" "$BRANCH" "$PUSH_REMOTE" "$PUBLISHED_BRANCH" >&2
    "$GIT" push -u "$PUSH_REMOTE" "HEAD:refs/heads/$PUBLISHED_BRANCH" || exit 1
    PR_HEAD="$PUBLISHED_BRANCH"
  else
    printf '%s\n' "$PUSH_OUTPUT" >&2
    exit 1
  fi
fi

Prepare a concise PR body in $BODY_FILE. Use this structure, omitting any section that is not applicable to the PR. Replace placeholder guidance with real content for sections that remain; do not leave empty headings or [[...]] placeholder text in the final PR description.

[[Add one line per confirmed issue, e.g., `Fixes #123` or `Fixes owner/repo#123`.
Omit this line when no issue reference is known.]]

## Motivation

[[The problem, grounded in a concrete example or motivating test case. Write for
a reviewer without the full context in their head.]]

## Proposed solution

[[The approach taken and why it is principled rather than a minimal-edit-distance
workaround.]]

## Change summary

[[The files/areas touched and what each one does. Wire claims to the source with
function names and `file.cpp:line` references.]]

## Concepts and vocabulary

[[A short glossary that restates only the codebase-specific or subtle terms the
process report relies on (e.g., witness, facet, the fixpoint solver, a non-obvious
distinction the fix hinges on). Do not explain basic, well-known concepts such as
interface or associated type — assume them. Omit this section if no such terms
are needed.]]

## Process report

[[Explain every change with a logical reason. For a change addressing a cascading
issue, describe the issue (with its motivating test case) and justify the fix with
a code trace — the exact functions/insts involved — explaining why it is necessary
and principled rather than a workaround. For any change that handles, guards, or
special-cases a particular input shape, answer the input-shape check: is that shape
itself correct and principled, or should its producer have been fixed instead? — so
a reviewer can confirm the fix sits at the right layer.]]

Ground each abstract claim in a concrete example, and wire explanations to the source (function name and file, or file.cpp:line). Do not include validation logs or a ## Test Plan section in the PR description.

If the PR is intentionally backward-compatibility breaking, include this section in the PR body:

## Breaking change
1. Existing systems and shaders may ...
2. Work around or resolve this by ...

The ## Breaking change section is required when the PR is intentionally backward-compatibility breaking or has the pr: breaking label. It must explain both the problems the PR may cause for existing systems and shaders, and how users can work around or properly resolve those problems.

When one or more fixed issue references are known, put one Fixes #123 line per fixed issue at the top of the PR body. Use the target repository's local issue number form for same-repository issues, and use Fixes owner/repo#123 only for cross-repository issues. Do not duplicate issue references, invent issue references, or include placeholder closing text. If no issue reference is known, omit Fixes lines.

Use at most one compatibility label: pr: non-breaking or pr: breaking. These labels cannot coexist. Use pr: breaking only when the change is clearly backward-compatibility breaking. Use pr: non-breaking only when the user says the PR is non-breaking or the non-breaking classification is otherwise clear. When the compatibility classification is unclear, do not guess and do not apply either label. Compatibility labels are optional metadata; if the target repository does not have the selected label, continue creating the PR without that label instead of creating labels or blocking PR creation. Only pass labels that exist in the target repository. This applies to compatibility labels such as pr: non-breaking or pr: breaking, and to integration labels such as CoPilot.

Create the PR:

LABEL_ARGS=()
LABEL_NAMES="$("$GH" label list \
  --repo "$REPO" \
  --limit 1000 \
  --json name \
  --jq '.[].name' 2>/dev/null | clean_line || true)"

repo_has_label() {
  label_name="$1"
  printf '%s\n' "$LABEL_NAMES" | grep -Fxq "$label_name"
}

add_label_if_available() {
  label_name="$1"
  if repo_has_label "$label_name"; then
    LABEL_ARGS+=(--label "$label_name")
  else
    printf 'Target repository is missing optional label: %s\n' "$label_name" >&2
    printf 'Creating the PR without that label.\n' >&2
  fi
}

BREAKING_CHANGE=false
NON_BREAKING_CHANGE=false
# Set BREAKING_CHANGE=true only when the user explicitly says the PR is breaking
# or the change is intentionally backward-compatibility breaking.
# Set NON_BREAKING_CHANGE=true only when the user says the PR is non-breaking or
# the non-breaking classification is otherwise clear. Leave both false when
# unclear.
COMPAT_LABEL=""
if [ "$BREAKING_CHANGE" = true ]; then
  COMPAT_LABEL="pr: breaking"
  BODY_FILE_READ="$BODY_FILE"
  if is_wsl && command -v wslpath >/dev/null 2>&1; then
    case "$BODY_FILE_READ" in
      *\\*|[A-Za-z]:*) BODY_FILE_READ="$(wslpath -u "$BODY_FILE_READ")" ;;
    esac
  fi
  BREAKING_HEADING_REGEX='^##[[:space:]]+Breaking change([[:space:]:]|$)'
  if ! grep -Eq "$BREAKING_HEADING_REGEX" "$BODY_FILE_READ"; then
    echo "Breaking PRs must include a '## Breaking change' section in the PR body."
    exit 1
  fi
elif [ "$NON_BREAKING_CHANGE" = true ]; then
  COMPAT_LABEL="pr: non-breaking"
fi
if [ -n "$COMPAT_LABEL" ]; then
  add_label_if_available "$COMPAT_LABEL"
fi

add_label_if_available "CoPilot"

DRAFT_ARGS=()
if [ "$DRAFT" = true ]; then
  DRAFT_ARGS=(--draft)
fi

request_coderabbit_review_if_draft() {
  pr_ref="$1"
  if [ "$DRAFT" = true ]; then
    "$GH" pr comment "$pr_ref" --body '@coderabbitai review'
  fi
}

PR_URL="$("$GH" pr create \
  --repo "$REPO" \
  --base "$BASE" \
  --head "$PR_HEAD" \
  --title "<title>" \
  --body-file "$BODY_FILE_ARG" \
  --assignee @me \
  "${DRAFT_ARGS[@]}" \
  "${LABEL_ARGS[@]}")" || exit 1
PR_URL="$(printf '%s\n' "$PR_URL" | clean_line)"
request_coderabbit_review_if_draft "$PR_URL"
printf '%s\n' "$PR_URL"

Keep --assignee @me in the command unless the user explicitly requests a different assignee.

If the branch was pushed to a fork rather than the target repository, use --head "<user>:<branch>" with the published branch name from PR_HEAD. Determine the fork owner from the push remote:

PUSH_URL="$("$GIT" remote get-url --push "$PUSH_REMOTE" | clean_line)"
HEAD_REPO="$("$GH" repo view "$PUSH_URL" --json nameWithOwner --jq .nameWithOwner | clean_line)"
HEAD_OWNER="${HEAD_REPO%%/*}"
PR_URL="$("$GH" pr create \
  --repo "$REPO" \
  --base "$BASE" \
  --head "$HEAD_OWNER:$PR_HEAD" \
  --title "<title>" \
  --body-file "$BODY_FILE_ARG" \
  --assignee @me \
  "${DRAFT_ARGS[@]}" \
  "${LABEL_ARGS[@]}")" || exit 1
PR_URL="$(printf '%s\n' "$PR_URL" | clean_line)"
request_coderabbit_review_if_draft "$PR_URL"
printf '%s\n' "$PR_URL"

For Windows PowerShell:

$GH = "gh.exe"
# Branch naming: preserve the current topic branch. Only when on the default
# branch (or detached HEAD) create a new topic branch named from the latest
# commit subject, then switch to it. Mirrors the Bash "Branch Naming" step.
if ([string]::IsNullOrEmpty($branch) -or $branch -eq $base) {
  $commitSubject = (git.exe log -1 --pretty=%s).Trim()
  $newBranch = $commitSubject.ToLower() -replace '[^a-z0-9]+', '-' -replace '^-+', '' -replace '-+$', ''
  if ($newBranch.Length -gt 50) {
    $newBranch = $newBranch.Substring(0, 50) -replace '-+$', ''
  }
  if ([string]::IsNullOrEmpty($newBranch)) {
    $shortHead = (git.exe rev-parse --short HEAD).Trim()
    $newBranch = "slang-pr-$shortHead"
  }

  $candidate = $newBranch
  $suffix = 1
  while (git.exe show-ref --verify --quiet "refs/heads/$candidate") {
    $suffix++
    $candidate = "${newBranch}-${suffix}"
  }
  $newBranch = $candidate

  git.exe switch -c $newBranch
  if ($LASTEXITCODE -ne 0) { exit 1 }
  $branch = $newBranch
  [Console]::Error.WriteLine("Was on default branch $base; created topic branch $branch for the PR.")
}

$headBranch = $branch
$repoNameWithOwner = $repo -replace '^https://github\.com/', '' -replace '^git@github\.com:', '' -replace '\.git$', ''
$bodyFile = (git.exe rev-parse --git-path slang-pr-body.md).Trim()
$breakingChange = $false
$nonBreakingChange = $false
# Set $breakingChange = $true only when the user explicitly says the PR is breaking
# or the change is intentionally backward-compatibility breaking.
# Set $nonBreakingChange = $true only when the user says the PR is non-breaking
# or the non-breaking classification is otherwise clear.
$compatLabel = $null
if ($breakingChange) {
  $compatLabel = "pr: breaking"
} elseif ($nonBreakingChange) {
  $compatLabel = "pr: non-breaking"
}
$hasBreakingChangeSection = Select-String -LiteralPath $bodyFile -SimpleMatch "## Breaking change" -Quiet
if ($breakingChange -and -not $hasBreakingChangeSection) {
  throw "Breaking PRs must include a '## Breaking change' section in the PR body."
}
$labelArgs = @()
$labelNames = @(& $GH label list `
  --repo $repoNameWithOwner `
  --limit 1000 `
  --json name `
  --jq ".[].name" 2>$null)
function Add-LabelIfAvailable {
  param([string]$LabelName)
  if ($labelNames | Where-Object { $_ -ceq $LabelName }) {
    $script:labelArgs += @("--label", $LabelName)
  } else {
    Write-Warning "Target repository is missing optional label: $LabelName"
    Write-Warning "Creating the PR without that label."
  }
}
if ($compatLabel) {
  Add-LabelIfAvailable $compatLabel
}
Add-LabelIfAvailable "CoPilot"
$prCreateArgs = @(
  "pr", "create",
  "--repo", $repo,
  "--base", $base,
  "--head", $headBranch,
  "--title", "PR title",
  "--body-file", $bodyFile,
  "--assignee", "@me"
)
if ($repoNameWithOwner -like "shader-slang/*") {
  $prCreateArgs += "--draft"
}
$prCreateArgs += $labelArgs
$prUrl = & $GH @prCreateArgs
if ($repoNameWithOwner -like "shader-slang/*") {
  & $GH pr comment $prUrl --body "@coderabbitai review"
}
$prUrl

Omit --draft for non-shader-slang/* targets. Also omit it if the user passes --no-draft or explicitly requests a shader-slang/* PR that is ready for review.

After Creation

Report the PR URL, the base branch, the published head branch, whether the push fell back to a new remote branch name, which labels were applied, whether a CodeRabbit review request was posted, and whether any validation was run. If PR creation fails because the branch was not pushed to a usable remote or the target repo differs from the local origin, explain the failure and ask before adding remotes or changing push destinations.