ProxmoxVE/.github/workflows/close-invalid-pr-template.yml

name: Flag PRs Missing Template

on:
  pull_request_target:
    branches: ["main"]
    types: [opened, edited, reopened, synchronize, labeled]

jobs:
  validate-pr-template:
    if: github.repository == 'community-scripts/ProxmoxVE'
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      issues: write
      contents: read
    steps:
      - name: Check PR against the template, comment and label instead of closing
        uses: actions/github-script@v9
        with:
          script: |
            const MARKER = "<!-- pr-template-check -->";
            const LABELS = ["missing pr template", "stale"];
            const pr = context.payload.pull_request;
            const prNumber = pr.number;
            const author = pr.user.login;
            const owner = context.repo.owner;
            const repo = context.repo.repo;

            const allowedBots = [
              "push-app-to-main[bot]",
              "push-app-to-main",
              "community-scripts-pr-app",
              "github-actions[bot]",
              "dependabot[bot]",
            ];

            if (allowedBots.includes(author) || author.endsWith("[bot]")) {
              core.info(`PR #${prNumber} by bot "${author}" — skipping template validation.`);
              return;
            }

            const association = pr.author_association;
            const exemptAssociations = ["OWNER", "MEMBER", "COLLABORATOR"];
            if (exemptAssociations.includes(association)) {
              core.info(`PR #${prNumber} by ${association} "${author}" — skipping template validation.`);
              return;
            }

            const prLabels = pr.labels.map((label) => label.name);
            const skipLabels = ["automated pr", "keep-open"];

            if (skipLabels.some((label) => prLabels.includes(label))) {
              core.info(`PR #${prNumber} has a skip label (${prLabels.join(", ")}) — skipping template validation.`);
              return;
            }

            if (pr.draft) {
              core.info(`PR #${prNumber} is a draft — skipping template validation.`);
              return;
            }

            const body = pr.body || "";
            const failures = [];

            const requiredSections = [
              "## ✍️ Description",
              "## ✅ Prerequisites",
              "## 🛠️ Type of Change",
            ];

            for (const section of requiredSections) {
              if (!body.includes(section)) {
                failures.push(`Missing required section: \`${section}\``);
              }
            }

            const descriptionMatch = body.match(
              /## ✍️ Description\s*\n+([\s\S]*?)(?=\n## )/i
            );
            const description = (descriptionMatch?.[1] || "").trim();
            if (!description) {
              failures.push("The **Description** section is empty.");
            }

            const prerequisiteCheckboxes = [
              "**Self-review completed**",
              "**Tested thoroughly**",
              "**No security risks**",
            ];

            for (const checkbox of prerequisiteCheckboxes) {
              const escaped = checkbox.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
              const regex = new RegExp(`- \\[(x|X)\\]\\s*${escaped}`, "i");
              if (!regex.test(body)) {
                failures.push(`Prerequisite not checked: ${checkbox}`);
              }
            }

            const typeOfChangeCheckboxes = [
              "🐞 **Bug fix**",
              "✨ **New feature**",
              "💥 **Breaking change**",
              "🆕 **New script**",
              "🌍 **Website update**",
              "🔧 **Refactoring / Code Cleanup**",
              "📝 **Documentation update**",
            ];

            const hasTypeChecked = typeOfChangeCheckboxes.some((checkbox) => {
              const escaped = checkbox.replace(/([.*+?^=!:${}()|[\]\/\\])/g, "\\$1");
              const regex = new RegExp(`- \\[(x|X)\\]\\s*${escaped}`, "i");
              return regex.test(body);
            });

            if (!hasTypeChecked) {
              failures.push("At least one **Type of Change** checkbox must be checked.");
            }

            const comments = await github.paginate(github.rest.issues.listComments, {
              owner, repo, issue_number: prNumber, per_page: 100
            });
            const mine = comments.find(c => c.body && c.body.includes(MARKER));

            if (failures.length === 0) {
              core.info(`PR #${prNumber} follows the PR template.`);
              if (mine && !mine.body.startsWith(MARKER + "\n✅")) {
                await github.rest.issues.updateComment({
                  owner, repo, comment_id: mine.id,
                  body: MARKER + "\n✅ **Template check passed.** Thanks for fixing the description — the `stale` mark has been removed.",
                });
              }
              for (const name of LABELS) {
                if (prLabels.includes(name)) {
                  await github.rest.issues.removeLabel({ owner, repo, issue_number: prNumber, name });
                }
              }
              return;
            }

            core.info(`PR #${prNumber} — template validation failed, flagging instead of closing.`);

            const templateUrl =
              "https://github.com/community-scripts/ProxmoxVE/blob/main/.github/pull_request_template.md";
            const failureList = failures.map((item) => `- ${item}`).join("\n");

            const text =
              MARKER + "\n" +
              `👋 Hi @${author},\n\n` +
              `This pull request does not follow the [PR template](${templateUrl}) yet:\n\n` +
              failureList + "\n\n" +
              `**Edit the PR description** to fix it — no new PR needed. This check runs again on every edit and clears itself once everything is in place.\n\n` +
              `Until then the PR is marked \`stale\` and will be closed in **7 days**.\n\n` +
              `Maintainers can add the \`keep-open\` label to exempt a PR from this check.\n\n` +
              `Thank you for contributing! 🙏`;

            if (mine) {
              if (mine.body !== text) {
                await github.rest.issues.updateComment({ owner, repo, comment_id: mine.id, body: text });
              }
            } else {
              await github.rest.issues.createComment({ owner, repo, issue_number: prNumber, body: text });
            }

            const toAdd = LABELS.filter(name => !prLabels.includes(name));
            if (toAdd.length > 0) {
              await github.rest.issues.addLabels({ owner, repo, issue_number: prNumber, labels: toAdd });
            }