Autolabel bot: optional draft field for path-based labeler.yml rules (#8020)

## Summary

Extends repo `labeler.yml` so each label rule can opt out of (or limit
to) draft pull requests. Path-based labels can stay on the legacy
list-of-globs form; new behavior uses a small object with `globs` and
optional `draft`.

When a PR's draft state changes, the bot also **removes** draft-gated
labels that no longer apply (e.g. `draft: false` labels when converted
to draft, `draft: true` labels when marked ready for review). Removal is
limited to labels the bot previously applied, so manually added labels
are left alone.

Logic lives in `labelerConfigUtils.ts`; `autoLabelBot.ts` imports it and
re-exports `getLabelsFromLabelerConfig` so existing imports keep
working.

## Motivation

torchtitan CI uses
[`labeler.yml`](https://github.com/pytorch/torchtitan/blob/main/.github/labeler.yml)
to apply labels that trigger CI on PRs. We want to avoid adding those
labels automatically on draft PRs to limit CI workloads, and remove them
if a PR is converted back to draft.

---

## `labeler.yml` schema

**Legacy (unchanged):**
```yaml
"module: dynamo":
  - torch/_dynamo/**
```

**Extended:**
```yaml
"ciflow/inductor":
  globs:
    - torch/_inductor/**
  draft: false
```

| `draft` | Behavior |
| -------- | -------- |
| (omitted) | Same as today: apply when paths match (draft or not). |
| `false` | Apply only when the PR is not a draft. |
| `true` | Apply only when the PR is a draft. |

## Code changes

| Area | Change |
| -------- | -------- |
| `torchci/lib/bot/labelerConfigUtils.ts` | New module: parsing,
`getLabelsFromLabelerConfig`, and `getDraftGatedLabelsToRemove`. |
| `torchci/lib/bot/autoLabelBot.ts` | Pass `pull_request.draft`; handle
`ready_for_review` and `converted_to_draft`; remove bot-applied
draft-gated labels on draft transitions; skip required-label comments on
`ready_for_review`. |
| `torchci/lib/bot/utils.ts` | No changes on this branch. |

## Tests added / updated

- `torchci/test/labelerConfigUtils.test.ts` — unit tests for parsing,
draft gating, and label removal helpers.
- `torchci/test/autoLabelBot.test.ts` — integration tests for adding
labels on draft vs non-draft PRs, removing labels on
`converted_to_draft` / `ready_for_review`, and no duplicate
required-label comments on `ready_for_review`.

## Test plan

- [x] From `torchci`, run: `jest test/labelerConfigUtils.test.ts`
- [x] Run path-based labeler integration tests: `jest
test/autoLabelBot.test.ts -t "labeler.yml config"`
- [x] (Recommended) full auto-label suite: `jest
test/autoLabelBot.test.ts`

Authored with assistance from Cursor

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 3 people

torchci/lib/bot/autoLabelBot.ts

@@ -1,6 +1,13 @@
-import { minimatch } from "minimatch";
 import { Context, Probot } from "probot";
-import { addLabelErrComment, hasRequiredLabels } from "./checkLabelsUtils";
+import {
+  addLabelErrComment,
+  hasRequiredLabels,
+  isBotAuthor,
+} from "./checkLabelsUtils";
+import {
+  getDraftGatedLabelsToRemove,
+  getLabelsFromLabelerConfig,
+} from "./labelerConfigUtils";
 import {
   addLabels,
   CachedIssueTracker,
@@ -13,6 +20,8 @@ import {
   LabelToLabelConfigTracker,
 } from "./utils";
 
+export { getLabelsFromLabelerConfig };
+
 // List of regex patterns for assigning labels to both Pull Requests and Issues
 const IssueAndPRRegexToLabel: [RegExp, string][] = [
   [/rocm/gi, "module: rocm"],
@@ -140,27 +149,6 @@ const notUserFacingPatterns: RegExp[] = [
 
 const notUserFacingPatternExceptions: RegExp[] = [/tools\/autograd/g];
 
-export async function getLabelsFromLabelerConfig(
-  context: Context,
-  labelerConfigTracker: CachedLabelerConfigTracker,
-  changed_files: string[]
-): Promise<string[]> {
-  const config = await labelerConfigTracker.loadLabelsConfig(context);
-
-  const labels = [];
-
-  for (const [label, globs] of Object.entries(config)) {
-    if (
-      globs.some((glob: string) =>
-        changed_files.some((file: string) => minimatch(file, glob))
-      )
-    ) {
-      labels.push(label);
-    }
-  }
-  return labels;
-}
-
 export async function getLabelsFromLabelToLabelConfig(
   context: Context,
   labelToLabelConfigTracker: LabelToLabelConfigTracker,
@@ -357,6 +345,39 @@ function getReleaseNotesCategoryAndTopic(
   return ["uncategorized", topic];
 }
 
+async function getBotAppliedLabels(
+  context: Context,
+  owner: string,
+  repo: string,
+  issueNumber: number,
+  labelNames: string[]
+): Promise<Set<string>> {
+  if (labelNames.length === 0) {
+    return new Set();
+  }
+  const lastLabeledBy = new Map<string, string>();
+  const events = await context.octokit.paginate(
+    context.octokit.issues.listEventsForTimeline,
+    context.repo({
+      issue_number: issueNumber,
+      per_page: 100,
+    })
+  );
+  for (const event of events) {
+    if (event.event === "labeled" && event.label?.name) {
+      lastLabeledBy.set(event.label.name, event.actor?.login ?? "");
+    }
+  }
+  const botApplied = new Set<string>();
+  for (const label of labelNames) {
+    const actor = lastLabeledBy.get(label) ?? "";
+    if (isBotAuthor(actor)) {
+      botApplied.add(label);
+    }
+  }
+  return botApplied;
+}
+
 export async function wasLabelRecentlyRemoved(
   context: Context,
   issueNumber: number,
@@ -504,7 +525,13 @@ function myBot(app: Probot): void {
   });
 
   app.on(
-    ["pull_request.opened", "pull_request.edited", "pull_request.synchronize"],
+    [
+      "pull_request.opened",
+      "pull_request.edited",
+      "pull_request.synchronize",
+      "pull_request.ready_for_review",
+      "pull_request.converted_to_draft",
+    ],
     async (context) => {
       const owner = context.payload.repository.owner.login;
       if (!isPyTorchbotSupportedOrg(owner)) {
@@ -547,10 +574,13 @@ function myBot(app: Probot): void {
         }
       }
 
+      const isDraft = context.payload.pull_request.draft;
+
       var labelsFromLabelerConfig = await getLabelsFromLabelerConfig(
         context,
         labelerConfigTracker,
-        filesChanged
+        filesChanged,
+        isDraft
       );
       labelsToAdd.push(...labelsFromLabelerConfig);
 
@@ -579,10 +609,38 @@ function myBot(app: Probot): void {
 
       await addNewLabels(labels, labelsToAdd, context);
 
+      const labelerConfig = await labelerConfigTracker.loadLabelsConfig(
+        context
+      );
+      const draftGatedToRemove = getDraftGatedLabelsToRemove(
+        labelerConfig as Record<string, unknown>,
+        filesChanged,
+        isDraft
+      ).filter((label) => labels.includes(label));
+      const botAppliedLabels = await getBotAppliedLabels(
+        context,
+        owner,
+        repo,
+        context.payload.pull_request.number,
+        draftGatedToRemove
+      );
+      for (const label of draftGatedToRemove) {
+        if (!botAppliedLabels.has(label)) {
+          continue;
+        }
+        await context.octokit.issues.removeLabel(
+          context.repo({
+            issue_number: context.payload.pull_request.number,
+            name: label,
+          })
+        );
+      }
+
       // After auto-labeling is complete, check if the PR still needs required labels.
       // We do this here instead of in checkLabelsBot to avoid a race condition where
       // checkLabelsBot posts an error comment before auto-labeling has a chance to
-      // add the required labels.
+      // add the required labels. Only run on opened (not ready_for_review) so draft
+      // transitions do not post duplicate required-label comments.
       if (
         isPyTorchPyTorch(owner, repo) &&
         context.payload.action === "opened"

torchci/lib/bot/checkLabelsUtils.ts

@@ -7,6 +7,10 @@ export const LABEL_COMMENT_END = "\n<!-- check-labels-comment-end -->";
 // Bot authors that can create the label error comment
 export const BOT_AUTHORS = ["github-actions", "pytorchmergebot", "pytorch-bot"];
 
+export function isBotAuthor(author: string): boolean {
+  return BOT_AUTHORS.includes(author.toLowerCase().replace("[bot]", ""));
+}
+
 // Error message title
 export const LABEL_ERR_MSG_TITLE = "This PR needs a `release notes:` label";
 
@@ -50,10 +54,7 @@ export function formLabelErrComment(): string {
  * Check if a comment is the label error comment.
  */
 export function isLabelErrComment(body: string, author: string): boolean {
-  return (
-    body.includes(LABEL_COMMENT_START) &&
-    BOT_AUTHORS.includes(author.toLowerCase().replace("[bot]", ""))
-  );
+  return body.includes(LABEL_COMMENT_START) && isBotAuthor(author);
 }
 
 /**

torchci/lib/bot/labelerConfigUtils.ts

@@ -0,0 +1,138 @@
+import { minimatch } from "minimatch";
+import { Context } from "probot";
+import { CachedLabelerConfigTracker } from "./utils";
+
+/** Legacy rules are a list of path globs; extended rules add optional draft behavior. */
+export type LabelerRule =
+  | string[]
+  | {
+      globs: string[];
+      /** false = skip label while PR is draft; true = only when draft; omit = always apply when globs match */
+      draft?: boolean;
+    };
+
+export function labelerRuleSkipReason(
+  rawRule: unknown
+): "invalid_draft" | "invalid_shape" | null {
+  if (
+    rawRule !== null &&
+    typeof rawRule === "object" &&
+    "globs" in rawRule &&
+    Array.isArray((rawRule as { globs: unknown }).globs) &&
+    (rawRule as { globs: unknown[] }).globs.every((x) => typeof x === "string")
+  ) {
+    const r = rawRule as { globs: string[]; draft?: unknown };
+    if ("draft" in r && typeof r.draft !== "boolean") {
+      return "invalid_draft";
+    }
+  }
+  return "invalid_shape";
+}
+
+export function normalizeLabelerRule(rule: unknown): LabelerRule | null {
+  if (Array.isArray(rule) && rule.every((x) => typeof x === "string")) {
+    return rule as string[];
+  }
+  if (
+    rule !== null &&
+    typeof rule === "object" &&
+    "globs" in rule &&
+    Array.isArray((rule as { globs: unknown }).globs) &&
+    (rule as { globs: unknown[] }).globs.every((x) => typeof x === "string")
+  ) {
+    const r = rule as { globs: string[]; draft?: unknown };
+    if ("draft" in r && typeof r.draft !== "boolean") {
+      return null;
+    }
+    const out: { globs: string[]; draft?: boolean } = { globs: r.globs };
+    if (typeof r.draft === "boolean") {
+      out.draft = r.draft;
+    }
+    return out;
+  }
+  return null;
+}
+
+export function globsFromRule(rule: LabelerRule): string[] {
+  return Array.isArray(rule) ? rule : rule.globs;
+}
+
+export function draftConstraintAllowsLabel(
+  rule: LabelerRule,
+  isDraft: boolean
+): boolean {
+  const draftOpt = Array.isArray(rule) ? undefined : rule.draft;
+  if (draftOpt === undefined) {
+    return true;
+  }
+  if (draftOpt === false) {
+    return !isDraft;
+  }
+  return isDraft;
+}
+
+export async function getLabelsFromLabelerConfig(
+  context: Context,
+  labelerConfigTracker: CachedLabelerConfigTracker,
+  changed_files: string[],
+  isDraft: boolean = false
+): Promise<string[]> {
+  const config = await labelerConfigTracker.loadLabelsConfig(context);
+  const labels: string[] = [];
+
+  for (const [label, rawRule] of Object.entries(config)) {
+    const rule = normalizeLabelerRule(rawRule);
+    if (rule === null) {
+      const skipReason = labelerRuleSkipReason(rawRule);
+      if (skipReason === "invalid_draft") {
+        context.log(
+          {
+            label,
+            rawRule,
+            draft: (rawRule as { draft?: unknown }).draft,
+          },
+          "getLabelsFromLabelerConfig: invalid draft type (expected boolean), skipping"
+        );
+      } else {
+        context.log(
+          { label, rawRule },
+          "getLabelsFromLabelerConfig: unknown rule shape, skipping"
+        );
+      }
+      continue;
+    }
+    if (!draftConstraintAllowsLabel(rule, isDraft)) {
+      continue;
+    }
+    const globs = globsFromRule(rule);
+    if (
+      globs.some((glob: string) =>
+        changed_files.some((file: string) => minimatch(file, glob))
+      )
+    ) {
+      labels.push(label);
+    }
+  }
+  return labels;
+}
+
+export function getDraftGatedLabelsToRemove(
+  config: Record<string, unknown>,
+  changed_files: string[],
+  isDraft: boolean
+): string[] {
+  const toRemove: string[] = [];
+  for (const [label, rawRule] of Object.entries(config)) {
+    const rule = normalizeLabelerRule(rawRule);
+    if (rule === null || Array.isArray(rule) || rule.draft === undefined) {
+      continue;
+    }
+    const globsMatch = globsFromRule(rule).some((glob) =>
+      changed_files.some((file) => minimatch(file, glob))
+    );
+    if (globsMatch && !draftConstraintAllowsLabel(rule, isDraft)) {
+      toRemove.push(label);
+    }
+  }
+  return toRemove;
+}