@duckduckgo/autoconsent 16.0.0 → 16.1.0

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -2,6 +2,13 @@ Task/Issue URL:
 
 ## Description:
 
+<!--
+Don't forget to label the PR.
+
+Impact: choose one of `major`, `minor`, or `patch`.
+Category: choose one of `rules`, `bug`, `enhancement`, `performance`, `dependencies`, `ci`, `ai`, `documentation`, `tests`, `internal`, or `other`.
+Details: https://github.com/duckduckgo/autoconsent/blob/main/docs/release-notes.md
+-->
 
 ## Steps to test this PR:
 

package/.github/labeler.yml

@@ -0,0 +1,36 @@
+ai:
+    - changed-files:
+          - any-glob-to-any-file:
+                - '.agents/**'
+                - 'AGENTS.md'
+                - 'CLAUDE.md'
+
+ci:
+    - changed-files:
+          - any-glob-to-any-file:
+                - '.github/**'
+                - 'ci/**'
+                - 'scripts/**'
+
+dependencies:
+    - changed-files:
+          - any-glob-to-any-file:
+                - 'package.json'
+                - 'package-lock.json'
+
+documentation:
+    - changed-files:
+          - any-glob-to-any-file:
+                - 'docs/**'
+
+rules:
+    - changed-files:
+          - any-glob-to-any-file:
+                - 'rules/**'
+                - 'tests/**/*.spec.ts'
+
+tests:
+    - changed-files:
+          - any-glob-to-any-file:
+                - 'playwright/**'
+                - 'web-test-runner.config.mjs'

package/.github/workflows/release-labels.yml

@@ -0,0 +1,110 @@
+name: Release Labels
+
+on:
+    pull_request_target:
+        types:
+            - opened
+            - reopened
+            - synchronize
+            - ready_for_review
+            - labeled
+            - unlabeled
+            - edited
+
+permissions:
+    contents: read
+    issues: write
+    pull-requests: write
+
+concurrency:
+    group: release-labels-${{ github.event.pull_request.number }}
+    cancel-in-progress: true
+
+jobs:
+    release-labels:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Apply path-based labels
+              if: >-
+                  ${{
+                    github.event.action == 'opened' ||
+                    github.event.action == 'reopened' ||
+                    github.event.action == 'ready_for_review'
+                  }}
+              uses: actions/labeler@v6
+              with:
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+                  sync-labels: false
+
+            - name: Use Node.js
+              uses: actions/setup-node@v4
+              with:
+                  node-version: lts/*
+                  cache: 'npm'
+
+            - name: Install dependencies
+              run: npm ci --ignore-scripts
+
+            - name: Check release labels
+              id: check_release_labels
+              continue-on-error: true
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+              run: |
+                  npm run check-pr-release-labels -- \
+                    --fetch-current-labels \
+                    --json-output "$RUNNER_TEMP/release-label-check.json"
+
+            - name: Comment on release label issues
+              if: always()
+              uses: actions/github-script@v7
+              with:
+                  script: |
+                      const fs = require('fs');
+
+                      const resultPath = `${process.env.RUNNER_TEMP}/release-label-check.json`;
+
+                      if (!fs.existsSync(resultPath)) {
+                          return;
+                      }
+
+                      const marker = '<!-- autoconsent-release-label-check -->';
+                      const result = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
+                      const { owner, repo } = context.repo;
+                      const issue_number = context.payload.pull_request.number;
+                      const { data: comments } = await github.rest.issues.listComments({
+                          owner,
+                          repo,
+                          issue_number,
+                          per_page: 100,
+                      });
+                      const existingComment = comments.find(
+                          (comment) => comment.user.type === 'Bot' && comment.body?.includes(marker)
+                      );
+
+                      if (!existingComment && result.ok) {
+                          return;
+                      }
+
+                      if (existingComment) {
+                          await github.rest.issues.updateComment({
+                              owner,
+                              repo,
+                              comment_id: existingComment.id,
+                              body: result.comment,
+                          });
+                          return;
+                      }
+
+                      await github.rest.issues.createComment({
+                          owner,
+                          repo,
+                          issue_number,
+                          body: result.comment,
+                      });
+
+            - name: Fail on release label issues
+              if: steps.check_release_labels.outcome == 'failure'
+              run: exit 1

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+# v16.1.0 (Fri Jun 26 2026)
+
+#### CI / Release Automation
+
+- Revamp release note labeling [#1410](https://github.com/duckduckgo/autoconsent/pull/1410) ([@cursoragent](https://github.com/cursoragent) [@muodov](https://github.com/muodov))
+
+#### Authors: 2
+
+- Cursor Agent ([@cursoragent](https://github.com/cursoragent))
+- Maxim Tsoy ([@muodov](https://github.com/muodov))
+
+---
+
 # v16.0.0 (Tue Jun 23 2026)
 
 #### 💥 Breaking Change

package/docs/release-notes.md

@@ -0,0 +1,65 @@
+# Release note labels
+
+Release notes are generated by `auto` from merged PR labels. Each PR that should
+appear in release notes needs two release-related decisions before merge:
+
+1. Exactly one release impact label.
+2. Exactly one primary release-note category label.
+
+Use `other` as the category for changes that should appear in release notes but
+do not fit another category.
+
+## Release impact labels
+
+Choose exactly one:
+
+| Label | Use when |
+| --- | --- |
+| `major` | The change is breaking for consumers or downstream app integration. |
+| `minor` | The change adds new behavior, rule coverage, or capabilities. |
+| `patch` | The change fixes existing behavior or makes a non-breaking maintenance update. |
+
+## Release-note category labels
+
+Choose exactly one category:
+
+| Label | Use when |
+| --- | --- |
+| `rules` | Adding, updating, or regenerating autoconsent rules. |
+| `bug` | Fixing broken behavior, including rule fixes and race-condition fixes. |
+| `enhancement` | Adding or improving non-rule functionality. |
+| `performance` | Improving runtime performance or measurement overhead. |
+| `dependencies` | Updating package dependencies. |
+| `ci` | Changing CI, release automation, or scripts used by automation. |
+| `ai` | Changing agent instructions, workflows, or skills. |
+| `documentation` | Documentation-only changes. |
+| `tests` | Changing test harnesses, fixtures, or test infrastructure. Do not use this for ordinary tests added with feature or rule work. |
+| `internal` | Internal-only maintenance that does not fit the categories above. |
+| `other` | Changes that should appear in release notes but do not fit another category. |
+
+## Common examples
+
+| PR type | Labels |
+| --- | --- |
+| New CMP rule or new site-specific rule | `minor`, `rules` |
+| Existing rule fix | `patch`, `bug` |
+| Generated rule update | `minor` or `patch`, `rules` |
+| Core API or integration breaking change | `major`, `enhancement` |
+| CI workflow or release script update | `patch`, `ci` |
+| Dependency update | `patch`, `dependencies` |
+| Agent skill or instruction update | `patch`, `ai` |
+| Documentation-only update | `patch`, `documentation` |
+| Test runner, fixture, or harness update | `patch`, `tests` |
+| Miscellaneous repo maintenance | `patch`, `other` |
+
+If a PR spans multiple categories, choose the category that best describes the
+user-visible release note. Mention secondary details in the PR description.
+
+## Syncing GitHub labels
+
+The label definitions live in `package.json` under the `auto.labels` config. If
+labels are missing or descriptions/colors drift, sync them with:
+
+```bash
+npx auto create-labels
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "16.0.0",
+  "version": "16.1.0",
   "description": "",
   "types": "./dist/types/web.d.ts",
   "exports": {
@@ -36,13 +36,15 @@
     "launch:firefox": "web-ext run -s dist/addon-firefox",
     "release": "auto shipit",
     "get-text-for-xpath": "ts-node scripts/get-text-for-xpath.ts",
-    "bundle-config-rules": "ts-node scripts/bundle-config-rules.ts"
+    "bundle-config-rules": "ts-node scripts/bundle-config-rules.ts",
+    "check-pr-release-labels": "ts-node scripts/check-pr-release-labels.ts"
   },
   "author": "Sam Macbeth",
   "license": "MPL-2.0",
   "devDependencies": {
     "@duckduckgo/eslint-config": "github:duckduckgo/eslint-config#v0.1.0",
     "@esm-bundle/chai": "^4.3.4-fix.0",
+    "@octokit/rest": "^22.0.1",
     "@playwright/test": "^1.17.1",
     "@types/chai": "^5.0.0",
     "@types/chrome": "^0.1.0",
@@ -76,6 +78,111 @@
   },
   "repository": "duckduckgo/autoconsent",
   "auto": {
+    "noDefaultLabels": true,
+    "labels": [
+      {
+        "name": "major",
+        "description": "Increment the major version when merged",
+        "releaseType": "major",
+        "color": "#C5000B"
+      },
+      {
+        "name": "minor",
+        "description": "Increment the minor version when merged",
+        "releaseType": "minor",
+        "color": "#F1A60E"
+      },
+      {
+        "name": "patch",
+        "description": "Increment the patch version when merged",
+        "releaseType": "patch",
+        "default": true,
+        "color": "#870048"
+      },
+      {
+        "name": "release",
+        "description": "Create a release when this PR is merged",
+        "releaseType": "release",
+        "color": "#007f70"
+      },
+      {
+        "name": "rules",
+        "changelogTitle": "Rules",
+        "description": "Autoconsent rule additions, updates, and generated rule changes",
+        "releaseType": "none",
+        "color": "#bfdadc"
+      },
+      {
+        "name": "bug",
+        "changelogTitle": "Bug Fixes",
+        "description": "Something isn't working",
+        "releaseType": "none",
+        "color": "#d73a4a"
+      },
+      {
+        "name": "enhancement",
+        "changelogTitle": "Enhancements",
+        "description": "New feature or request",
+        "releaseType": "none",
+        "color": "#a2eeef"
+      },
+      {
+        "name": "performance",
+        "changelogTitle": "Performance",
+        "description": "Improve performance of an existing feature",
+        "releaseType": "none",
+        "color": "#f4b2d8"
+      },
+      {
+        "name": "dependencies",
+        "changelogTitle": "Dependencies",
+        "description": "Update one or more dependencies version",
+        "releaseType": "none",
+        "color": "#8732bc"
+      },
+      {
+        "name": "ci",
+        "changelogTitle": "CI / Release Automation",
+        "description": "Automation scripts and release infrastructure",
+        "releaseType": "none",
+        "color": "#2612BF"
+      },
+      {
+        "name": "ai",
+        "changelogTitle": "AI / Agent Workflow",
+        "description": "Changes to agent workflows and skills",
+        "releaseType": "none",
+        "color": "#df4f06"
+      },
+      {
+        "name": "documentation",
+        "changelogTitle": "Documentation",
+        "description": "Changes only affect the documentation",
+        "releaseType": "none",
+        "color": "#cfd3d7"
+      },
+      {
+        "name": "tests",
+        "changelogTitle": "Test Infrastructure",
+        "description": "Changes to test harnesses, fixtures, or test infrastructure",
+        "releaseType": "none",
+        "color": "#ffd3cc"
+      },
+      {
+        "name": "internal",
+        "changelogTitle": "Internal",
+        "description": "Changes only affect internal implementation details",
+        "releaseType": "none",
+        "color": "#696969"
+      },
+      {
+        "name": "other",
+        "changelogTitle": "Other",
+        "description": "Changes that should appear in release notes but do not fit another category",
+        "releaseType": "none",
+        "color": "#ededed"
+      }
+    ],
     "plugins": [
       "npm"
     ]

package/scripts/check-pr-release-labels.ts

@@ -0,0 +1,255 @@
+import fs from 'fs';
+import { Octokit } from '@octokit/rest';
+
+const RELEASE_IMPACT_LABELS = ['major', 'minor', 'patch'] as const;
+const CATEGORY_LABELS = [
+    'rules',
+    'bug',
+    'enhancement',
+    'performance',
+    'dependencies',
+    'ci',
+    'ai',
+    'documentation',
+    'tests',
+    'internal',
+    'other',
+] as const;
+const COMMENT_MARKER = '<!-- autoconsent-release-label-check -->';
+
+type LabelName = (typeof RELEASE_IMPACT_LABELS)[number] | (typeof CATEGORY_LABELS)[number];
+
+interface Args {
+    event?: string;
+    fetchCurrentLabels?: boolean;
+    jsonOutput?: string;
+    labels?: string[];
+}
+
+interface PullRequestLabel {
+    name: string;
+}
+
+interface PullRequest {
+    labels?: Array<string | PullRequestLabel>;
+    number: number;
+}
+
+interface PullRequestEvent {
+    pull_request?: PullRequest;
+    labels?: Array<string | PullRequestLabel>;
+    number?: number;
+}
+
+interface ValidationResult {
+    ok: boolean;
+    labels: string[];
+    releaseImpactLabels: string[];
+    categoryLabels: string[];
+    errors: string[];
+    comment?: string;
+}
+
+function parseArgs(argv: string[]): Args {
+    const args: Args = {};
+
+    for (let i = 2; i < argv.length; i += 1) {
+        const arg = argv[i];
+
+        if (arg === '--fetch-current-labels') {
+            args.fetchCurrentLabels = true;
+        } else if (arg === '--event') {
+            args.event = argv[(i += 1)];
+        } else if (arg === '--json-output') {
+            args.jsonOutput = argv[(i += 1)];
+        } else if (arg === '--labels') {
+            args.labels = argv[(i += 1)]
+                .split(',')
+                .map((label) => label.trim())
+                .filter(Boolean);
+        } else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+
+    return args;
+}
+
+function readJson(filePath: string): unknown {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function readEvent(eventPath?: string): PullRequestEvent {
+    if (!eventPath) {
+        return {};
+    }
+
+    return readJson(eventPath) as PullRequestEvent;
+}
+
+function getPullRequest(event: PullRequestEvent): PullRequest | undefined {
+    if (event.pull_request) {
+        return event.pull_request;
+    }
+
+    if (event.number && event.labels) {
+        return event as PullRequest;
+    }
+
+    return undefined;
+}
+
+function getLabelsFromPullRequest(pullRequest: Pick<PullRequest, 'labels'>): string[] {
+    return (pullRequest.labels || []).map((label) => {
+        if (typeof label === 'string') {
+            return label;
+        }
+
+        return label.name;
+    });
+}
+
+function uniqueLabels(labels: string[]): string[] {
+    return [...new Set(labels)].sort((a, b) => a.localeCompare(b));
+}
+
+function isKnownLabel(labelSet: readonly LabelName[], label: string): boolean {
+    return labelSet.some((knownLabel) => knownLabel === label);
+}
+
+export function validateLabels(labels: string[]): ValidationResult {
+    const currentLabels = uniqueLabels(labels);
+    const releaseImpactLabels = currentLabels.filter((label) => isKnownLabel(RELEASE_IMPACT_LABELS, label));
+    const categoryLabels = currentLabels.filter((label) => isKnownLabel(CATEGORY_LABELS, label));
+    const errors: string[] = [];
+
+    if (releaseImpactLabels.length === 0) {
+        errors.push(`Add exactly one release impact label: ${RELEASE_IMPACT_LABELS.join(', ')}.`);
+    } else if (releaseImpactLabels.length > 1) {
+        errors.push(`Keep exactly one release impact label; found ${releaseImpactLabels.join(', ')}.`);
+    }
+
+    if (categoryLabels.length === 0) {
+        errors.push(`Add exactly one release-note category label: ${CATEGORY_LABELS.join(', ')}.`);
+    } else if (categoryLabels.length > 1) {
+        errors.push(`Keep exactly one release-note category label; found ${categoryLabels.join(', ')}.`);
+    }
+
+    return {
+        ok: errors.length === 0,
+        labels: currentLabels,
+        releaseImpactLabels,
+        categoryLabels,
+        errors,
+    };
+}
+
+function formatLabels(labels: readonly string[]): string {
+    if (labels.length === 0) {
+        return '_none_';
+    }
+
+    return labels.map((label) => `\`${label}\``).join(', ');
+}
+
+function formatComment(result: ValidationResult): string {
+    if (result.ok) {
+        return `${COMMENT_MARKER}
+### Release label check resolved
+
+The release labels are valid.`;
+    }
+
+    return `${COMMENT_MARKER}
+### Release label check failed
+
+Please update this PR's release labels before merging.
+
+Current labels: ${formatLabels(result.labels)}
+
+Problems:
+${result.errors.map((error) => `- ${error}`).join('\n')}
+
+Required labels:
+- One release impact label: ${formatLabels(RELEASE_IMPACT_LABELS)}
+- One release-note category label: ${formatLabels(CATEGORY_LABELS)}
+
+See [docs/release-notes.md](https://github.com/duckduckgo/autoconsent/blob/main/docs/release-notes.md) for examples.`;
+}
+
+function getRepositoryParts(repository: string): { owner: string; repo: string } {
+    const [owner, repo] = repository.split('/');
+
+    if (!owner || !repo) {
+        throw new Error(`Invalid GITHUB_REPOSITORY value: ${repository}`);
+    }
+
+    return { owner, repo };
+}
+
+async function fetchCurrentLabels(event: PullRequestEvent): Promise<string[]> {
+    const pullRequest = getPullRequest(event);
+    const repository = process.env.GITHUB_REPOSITORY;
+
+    if (!pullRequest || !repository) {
+        throw new Error('Cannot fetch current labels without a pull request event and repository.');
+    }
+
+    const { owner, repo } = getRepositoryParts(repository);
+    const octokit = new Octokit({
+        auth: process.env.GITHUB_TOKEN,
+        baseUrl: process.env.GITHUB_API_URL || 'https://api.github.com',
+    });
+    const labels = await octokit.paginate(octokit.rest.issues.listLabelsOnIssue, {
+        owner,
+        repo,
+        issue_number: pullRequest.number,
+        per_page: 100,
+    });
+
+    return labels.map((label) => label.name);
+}
+
+async function main(): Promise<void> {
+    const args = parseArgs(process.argv);
+    const eventPath = args.event || process.env.GITHUB_EVENT_PATH;
+    const event = readEvent(eventPath);
+    const pullRequest = getPullRequest(event);
+    let labels = args.labels;
+
+    if (!labels && args.fetchCurrentLabels) {
+        labels = await fetchCurrentLabels(event);
+    }
+
+    if (!labels && pullRequest) {
+        labels = getLabelsFromPullRequest(pullRequest);
+    }
+
+    if (!labels) {
+        throw new Error('No pull request labels found to validate.');
+    }
+
+    const result: ValidationResult = validateLabels(labels);
+    result.comment = formatComment(result);
+
+    if (args.jsonOutput) {
+        fs.writeFileSync(args.jsonOutput, `${JSON.stringify(result, null, 2)}\n`);
+    }
+
+    if (result.ok) {
+        console.log('Release labels look good.');
+    } else {
+        console.error(result.comment);
+    }
+
+    process.exit(result.ok ? 0 : 1);
+}
+
+if (require.main === module) {
+    main().catch((error: unknown) => {
+        console.error(error instanceof Error ? error.message : error);
+        process.exit(1);
+    });
+}
+
+export { CATEGORY_LABELS, RELEASE_IMPACT_LABELS };