necojackarc/auto-request-review

A GitHub Action that automatically requests review of a pull request based on files changes and/or groups the author belongs to 🤖

auto-request-review's Issues

Cannot use local file

Hello! Our team recently came across this workflow and wants to implement it in our organization. Unfortunately, it looks like it pulls the config file from the repo always instead of locally during the action.

We have many devs and constantly are rolling devs on and off the project so it would be not a great solution for us to maintain every single repo we have with this config file. Instead, we were hoping to store this file somewhere else and then pull it into the local repo at .github/auto_request_review.yml prior to running this step.

Is it possible to do this today and we missed it or would it be possible to add this option, as not only would this make our lives much easier, but it would also help solve issues like #12 where the config file exists in the PR but not yet the repo. Thank you!

File matched, but no assignment occurred

Looking at my output, I see the following:

Run shufo/[email protected]
{
  '.github/**/*.yml': [ 'dep' ],
  'config/**/*': [ 'dep' ],
  'scripts/*': [ 'dep' ],
  'package.json': [ 'dep' ],
  'manifest.json': [ 'dep' ],
  Makefile: [ 'dep' ]
}
  .github/assign-by-files.yml matches .github/**/*.yml
  Makefile matches Makefile
finished!

Though no assignment occurred in the PR:

Workflow:

name: "👷🏻‍♂️ Auto Assign"
on:
  - pull_request

jobs:
  assign_reviewer:
    runs-on: ubuntu-latest
    steps:
      - uses: shufo/[email protected]
        with:
          config: ".github/assign-by-files.yml"
          token: ${{ secrets.GITHUB_TOKEN }}

Config:

---
".github/**/*.yml":
  - dep

"config/**/*":
  - dep

"scripts/*":
  - dep

"package.json":
  - dep

"manifest.json":
  - dep

"Makefile":
  - dep

Thanks for any help!

auto-request-review doesn't add reviewers from github team.

Hi,
Normal configuration with list of reviewer works. Thanks a lot. It is very useful action.

I have an issue with using github team. The action doesn't add reviewers from a github team.

Logs:

with:
    token: ***
    config: .github/config/reviewers.yaml
Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
A "files" key does not exist in config; returning no reviewers for changed files.
Identifying reviewers based on the author
Adding other group members to reviewers if group assignment feature is on
Group assignment feature is enabled
Randomly picking reviewers if the number of reviewers is set
Requesting review to team:my-team

Configuration:

- name: Auto request review
   uses: necojackarc/auto-request-review@91e252d75fe335f586be7e243c39e5dd88f2e153
   with:
      token: ${{ secrets.GIT_PAT }}
      config: .github/config/reviewers.yaml

reviewers.yaml

reviewers:
  per_author:
    lurbanski-equinix:
      - team:my-team

options:
  ignore_draft: false
  enable_group_assignment: true

I also tried to set "Enable auto assignment" in the team settings, but it doesn't work as well.
My GIT_PAT has full access to repo.

Don't re-request review if approval is already present for that reviewer

It seems the auto-request will start even if a suitable reviewer has already approved the PR. This creates a lot of noise.

"Review cannot be requested from pull request author." error thrown when a default reviewer opens a PR.

When the PR author is assigned as a default reviewer, the action fails with the error "Review cannot be requested from pull request author." .

Expected behavior:
Simply skip the reviewer addition if the reviewer is the same as the PR author.

Github - Node.js 16 actions are deprecated.

[Auto Request Review]
Node.js 16 actions are deprecated. Please update the following actions to use Node.js 20: necojackarc/[email protected]. For more information see: https://github.blog/changelog/2023-09-22-github-actions-transitioning-from-node-16-to-node-20/.

bug: workflow failed due to trying to request author as reviewer

Overview

Github user Nashqueue submitted a PR and the workflow failed to assign reviewers because the workflow picked Nashqueue as a reviewer.

Can we update the workflow to proactively check the PR author and exclude them from the list of potential reviewers?

Log

Example failure:
https://github.com/rollkit/rollkit/actions/runs/6533811456/job/17739738877

Run necojackarc/[email protected]
  with:
    token: ***
    config: .github/auto_request_review.yml
    use_local: false
Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
Identifying reviewers based on the author
"per_author" is not set; returning no reviewers for the author.
Adding other group members to reviewers if group assignment feature is on
Group assignment feature is disabled
Randomly picking reviewers if the number of reviewers is set
Requesting review to Manav-Aggarwal, tuxcanfly, Nashqueue
Error: HttpError: Review cannot be requested from pull request author.

auto_request_review.yml

reviewers:
  defaults:
    - code-owners
  groups:
    code-owners:
      - Nashqueue
      - tzdybal
      - gupadhyaya
    rollkit:
      - Manav-Aggarwal
      - S1nus
      - tuxcanfly
    devops:
      - smuu
      - sysrex
      - jrmanes
      - Bidon15
    celestia:
      - team:celestia
files:
  '**':
    - code-owners
    - rollkit
  '**/*Dockerfile':
    - devops
  '.github/**':
    - devops
options:
  ignore_draft: true
  ignored_keywords:
    - WIP
  number_of_reviewers: 3

workflow yml

  # See https://github.com/marketplace/actions/auto-request-review for more
  # information on how to use this action
  auto-request-review:
    if: ${{ inputs.run-auto-request-review }}
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - uses: necojackarc/[email protected]
        with:
          # There is a rollkit level PAT_FOR_AUTO_REQUEST_REVIEW secret that
          # belongs to MSevey who should have sufficient access for all public
          # repos
          token: ${{ secrets.PAT_FOR_AUTO_REQUEST_REVIEW }}

cc @nashqueue

Don't set auto reviewers if they’re already set manually

We got a bit confusing thing. When we setting needed reviewers manually (in draft PR mode), auto-request sets number_of_reviewers reviewers anyway.

So could we make some flag in yaml that will prevent adding extra reviewers. If we set 2 reviewers manually and number_of_reviewers=3 auto-request will set 1 more reviewer. That flag could be named count_manual_reviewers

Multiple glob patterns for the same group of reviewers

Hello! Thanks for the nice tool, it's really helpful!

I'd like to ask if the following use case is supported: I want to define multiple glob patterns and all of them to have the same group assigned. This is helpful when I can't combine multiple glob patterns into a single one. For example:

files:
  'main/!(subFolder)**/*':
  'main/!(subFolder)*':
    - reviewersGroup

Thanks.

Can't find a configuration file at the initial setup

As the action fetches the configuration file stored in the target branch, you'll see a Not Found error when you set up the action first. This should put off users, so fix it.

##[error]HttpError: Not Found

Probably, just terminating the process saying something like "Configuration file is not found; terminating the action" may be fine.

Bump to Node.js 16

Node.js versjon 12 actions are deprecated, and Github has added a warning when using actions using this action.

Node.js 12 actions are deprecated. For more information see: https://github.blog/changelog/2022-09-22-github-actions-all-actions-will-begin-running-on-node16-instead-of-node12/. Please update the following actions to use Node.js 16: necojackarc/auto-request-review

Is it possible to bump node version to Node.js 16?

Sutb/Mock/Fake GitHub Action code and add tests

All code that needs to interact with GitHub Action is now not tested.
It would be better to add stubs/mocks/fakes or any appropriate test doubles and test them.

These lines in index.js may significantly decrease the testability:

https://github.com/necojackarc/request-review-based-on-files/blob/bd161db8586ed7667724f7d01f60f4b00c458258/src/index.js#L11-L14

Possibly, it would be better not to have such logic at the top level.
It would be better to revisit the module structure as well.

Allow for specifying reviewers for each member

The current implementation is best for the teams where all members review all PRs.
However, in some teams, the following case can happen, for instance:

• Head of Design reviews only Lead Designer's changes
• Lead Designer reviews Head of Design's, Member A's and B's changes
• Member A reviews Lead Designer's changes
• Member B doesn't review changes at all

In other words,

• Member A has Lead Designer review their code
• Member B has Lead Designer review their code
• Lead Designer has Member A and Head of Design review their code

reviewer \ reviewee	Head of Design	Lead Designer	Member A	Member B
Head of Design	-	Y	N	N
Lead Designer	Y	-	Y	Y
Member A	N	Y	-	N
Member B	N	N	N	-

Solution

Add a per_author key to reviewers. The settings file will look like:

reviewers:
  defaults:
    - engineers

  groups:
    engineers:
      - engineer_a
      - engineer_b
      - engineer_c
    designers:
      - head_of_design
      - lead_designer
      - desinger_a
      - designer_b

  # Reviwers for each author
  per_author:
    engineers:
      - engineers
    head_of_design:
      - lead_designer
    lead_designer:
      - head_of_design
      - designer_a
    designer_a:
      - lead_designer
    designer_b:
      - lead_desinger

Update the token with necessary permissions to assign reviewers

Currently, on this repository, to use this GitHub action, I use GITHUB_TOKEN.

auto-request-review/.github/workflows/auto_request_review.yml

Line 15 in de08bc0

token: ${{ secrets.GITHUB_TOKEN }}

However, this doesn't have necessary permissions - see Permissions for the GITHUB_TOKEN. Probably, a repo scoped token should be used to assign reviewers (ref: peter-evans/create-pull-request#155 (comment)).

• Configure the repository to allow only selected GitHub actions can run
  • As I'll set a token with some write access, I should limit the actions that can run
  • See Disabling or limiting GitHub Actions for your organization
• Create a token with the repo access
• Update the workflow file to use that token
• Update README to explain what token should be used in this case where read-only members want to assign reviewers with this GitHub Action

Mention non-collaborators instead of requesting review from them and fail

Hello, I'm trying to use this action in one of the repos that I contribute to, but it seems you can only request review from collaborators, see this test action. Since our repo has many contributors, giving collaborator rights to each of them who is willing or wish to review is not really feasible.

I'm thinking perhaps this action can be extended to write a comment to mention the people that cannot be requested for review because they don't have collaborator rights. I searched for other actions and the closest thing I was able to find that has something similar to what I want to do is this action, which seems to be not longer maintained and only supports mentioning according to labels, so I think this action is closest to what I want.

Add a release task to package.json

Add npm run release to package.json that will do:

• Build a package (npm run build)
• Increment a version
  • I think there are some convenient commands provided by npm to bump versions
• Commit and tag it

Add enable_group_assignment option

Depending on the structure of your team, it varies that which assignment method is more convenient, file-based or group-based. Say your team consists of only designers and full-stack engineers, what you need is perhaps assign all other members of the team the author belongs to.

Adding this feature may contradict one of the UNIX philosophies "Do One Thing and Do It Well", however, if it's possible to add this option as a small convenient option without breaking the main concept of the action, it'd worth considering.

Make `repository-owners` actually evaluate to the repo owners

To be honest when I first saw the example I assumed that repository-owners was a magic name that automatically resolved to the list of owners for the current repository.

It was only when I more closely examined some of the other examples I realised that it's nothing special and just the name of a user-defined group.

But what if it was a magic name (or use something similar eg. repo:owners) that did resolve to the owners of the repository. I think that would be useful.

Add default reviewers so that you can always send review requests

Sometimes, no reviewers can be matched depending on your configuration.
It's quite possibly that you'd like to avoid that situation to make sure you can notice pull requests that await someone.

I think adding the default key under reviewers looks good for this.

reviewers:
  default:
    - repository-owner # group
    - someone # individual

The expected behaviour is like:

• Find reviewers based on changed files
• Find reviewers based on groups if enable_group_assignment is true
• If no reviewers are found, assign the default reviewers to the pull request in question

Using default reviews and files, no reviewers are matched

Hi! 👋 Thanks for making this action, it looks like exactly what we need. Unfortunately, it isn't working.

I'm not quite sure what is wrong here, but the expectation is that any files outside of the two directories would be automatically assigned to team:leads

With files changed in .github, given this configuration:

reviewers:
  default:
    - team:leads

files:
  'clients/**':
    - team:frontend
    - team:leads
  'api/**':
    - team:backend
    - team:leads

options:
  ignore_draft: true

No reviewers are assigned:

Run necojackarc/auto-request-review@e08cdffa277d50854744de3f76230260e61c67f4
  with:
    token: ***
    config: .github/auto_request_review.yml
Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
Identifying reviewers based on the author
"per_author" is not set; returning no reviewers for the author.
Adding other group membres to reviewers if group assignment feature is on
Group assignment feature is disabled
Matched no reviewers
No default reviewers are matched; terminating the process

So I tried a ** glob, and still none are assigned:

files:
  # Keys are glob expressions.
  # You can assign groups defined above as well as GitHub usernames.
  'clients/**':
    - team:frontend
    - team:leads
  'api/**':
    - team:backend
    - team:leads
  '**':
    - team:leads

options:
  ignore_draft: true

Same result:

Run necojackarc/auto-request-review@e08cdffa277d50854744de3f76230260e61c67f4
  with:
    token: ***
    config: .github/auto_request_review.yml
Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
Identifying reviewers based on the author
"per_author" is not set; returning no reviewers for the author.
Adding other group membres to reviewers if group assignment feature is on
Group assignment feature is disabled
Matched no reviewers
No default reviewers are matched; terminating the process

Is this a bug? Have I missed something? Thank you!

Trying to parse config throwing vague error

Here is my config file labeled reviewers.yml

reviewers:
  # The default reviewers
  defaults:
    - team:core-qa # GitHub team

  # Reviewer groups each of which has a list of GitHub usernames
  groups:
    qa:
      - team:core-qa
    engineers:
      - team:core-fe-devs

  # Reviewers per author.
  # Keys are reviewees, each of which has an array of reviewers.
  per_author:
    engineers:
      - team:core-qa # GitHub team

Whenever I run the action I get this error:
Error: TypeError: Cannot read properties of undefined (reading 'title')

There is no title key in the yaml file. Have you faced this issue before? What is wrong with my config file that causes this typerror?

Unable to use github team

Hello,

I just don't know what I'm doing wrong...

workflow

name: Add default reviewers
run-name: Add default reviewers
on:
  pull_request:
    types: [opened, ready_for_review, reopened]
jobs:
  add-default-reviewers:
    runs-on: self-hosted
    steps:
      - name: Auto Request Review
        uses: necojackarc/[email protected]
        with:
          token: ${{ secrets.PAT_FOR_AUTO_REQUEST_REVIEW }}
          config: .github/reviewers.yaml

reviewers.yaml

reviewers:
  defaults:
    - team:devops
options:
  ignore_draft: true

PAT_FOR_AUTO_REQUEST_REVIEW has full access to all repos

The funny thing is, when I remove devops team from collaborators the job succeed but no reviewers are added. When I'm adding it with admin role, the error is:

Error: HttpError: Reviews may only be requested from collaborators. One or more of the users or teams you specified is not a collaborator of the HardRockDigital/lt-test repository.

Auto Request Review not adding reviewers

I am trying to use this GitHub action to add reviewers based on if certain files change. Unfortunately, for whatever reason the action says "Requesting review..." but no reviewers are ever added to the pull request.

Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
Identifying reviewers based on the author
"per_author" is not set; returning no reviewers for the author.
Adding other group membres to reviewers if group assignment feature is on
Group assignment feature is disabled
Randomly picking reviewers if the number of reviewers is set
Requesting review to matt.messa, dave.brennan

Has anyone seen anything like this, and is there any troubleshooting steps I should attempt? I've already tried creating a new PAT and adding it as a secret to the repo. That did not work as well.

Wondering if there is some security settings or something I may be unaware of.

Hoping to use this. Let me know!

Best,
Matt

Support for monorepo / cross-team repositories

I'm hoping to inquire whether the following use-case is supported:

Team 1 - Maintainers
Team 1 - Contributors
Team 2 - Maintainers
Team 2 - Contributors

For a given glob, ask for review from 1 member of each maintainer group and the rest of the contributor group of the member who created the pull request.

This is an important use-case for repositories used across multiple teams (i.e., monorepos). Happy to elaborate and work toward a solution if this is not possible. Thanks!

"last_files_match_only=true" only adds one alias as a reviewer, regardless of number of edited files

Problem

Currently, I have a repository with the action setup to have last_files_match_only=true. When I open a PR with multiple files edited inside the PR that each have their own alias associated with them, I would expect that a single alias for each file edited would be added to the PR.

codereviewers.yml

files:
  'include/client.h':
    - jamoor-john-doe
  'src/**':
    - jamoor
  'src/client.cpp':
    - jamoor-test
options:
  ignore_draft: true
  last_files_match_only: true

Changes in PR

Expected Behavior

Actual Behavior

Context

Based on the PR that added the last_files_match_only=true functionality (#80), it looks like the intention was to have the files section of codereviewers.yml to match the behavior of github's codeowners file.

I've setup a test repo (https://github.com/jamoor-moj/codereview_demo) that I can compare the behavior of codeowners and codereviewers (which is where I got the screenshots of the behavior above)

Codeowners: jamoor-moj/codereview_demo#4

  include/client.h @jamoor-john-doe
  src/ @jamoor
  src/client.cpp @jamoor-test

Codereviewers: jamoor-moj/codereview_demo#5

files:
  'include/client.h':
    - jamoor-john-doe
  'src/**':
    - jamoor
  'src/client.cpp':
    - jamoor-test
options:
  ignore_draft: true
  last_files_match_only: true

Is my understanding correct that this was the intention and therefore this is a bug? Or was that not the intention and this is an enhancement?

How to re-request review

I would like to know how can I re-request reviews. it seems there is no way to do this with the current version.

"explode" GitHub team when using as a reviewer group

In our pipeline we have a config similar to this:

reviewers:
  defaults:
    - team:a

  # Reviewer groups each of which has a list of GitHub usernames
  groups:
    a:
      - team:a
    b: 
      - team:b
     
  "**/*.go":
    - team:a
  "**/*.js":
    - team:b

options:
  ignore_draft: true
  number_of_reviewers: 2

At the moment, this will assign the actual GitHub team for the given file changes. I would like it to assign 2 users from inside these teams instead of the team as a whole. Is this possible? It would allow us to manage the groups via GitHub rather than listing users in the config manually which requires us to commit changes any time the teams change.

Hidden files not covered by ** glob

Using this example:

files:
  # Keys are glob expressions.
  # You can assign groups defined above as well as GitHub usernames.
  '**':
    - repository-owners # group
    - team:external-reviewers # GitHub team

if the PR only contain changes files inside a hidden folder (e.g. .github), the reviewers are not added.

Output:

No default reviewers are matched; terminating the process

Github Team doesn't work as a group

I have a github team that I'm trying to automatically request reviews by all team members, for all team members.

Ex: team-1 consists of [dev1, dev2, dev3]. If dev2 submits a PR, I want dev1 and dev3 to be requested automatically. However, only the following seems to work:

reviewers:
  groups:
    group-1
      - dev1
      - dev2
      - dev3

  per_author:
    group-1
      - team:team-1

I would have expected this to work, too:

reviewers:
  groups:
    group-1
      - team:team-1

  per_author:
    group-1
      - team:team-1

Setting enable_group_assignment: true doesn't work, either. Is there a way to do this that I'm missing?

Re-request review from different reviewers

Hi there,

is there currently a way to re-request review from a different person (let's say person B) if the person A did not review the PR in X hours?

E.g. Reviewer A did not review the PR in 24 hours, so he/she will be removed from reviewers and another person will be assigned.

I couldn't find any use case, neither in the issues nor in the docs.

If it's not possible, maybe I can try to implement this, but i have no idea from where to start, so it would take some time :D

Thanks!

"last_files_match_only" does not work when pattern owner is a team

Problem

When I have a pattern with a team set as reviewer, and a more specific pattern with a specific individual as reviewer, and have last_files_match_only = true, I get both the team and the individual as reviewers when changing the file for the specific pattern.

Expected behavior would be that only the specific individual is assigned as reviewer.

Note: If both the general and the specific pattern have individuals as reviewers the behavior is as expected. This bug only happens when the general pattern has a team as reviewer.

Mock up screenshot of what's happening:

Expected behavior:

Context

I have the following CODEOWNERS reference file (with the actual organization and team names changed):

src/gui/ @MyOrg/some-team
src/gui/gui.c @specific-user

I have the following reviewers.yaml file:

files:
  'src/gui/**':
    - team:some-team
  'src/gui/gui.c':
    - specific-user

last_files_match_only: true

I have the following workflow:

name: Auto Request Review

on:
  pull_request:
    types: [opened, ready_for_review, reopened]

jobs:
  auto_request_review:
    name: Auto Request Review
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Request review based on files changes and/or groups the author belongs to
        uses: necojackarc/[email protected]
        with:
          token: ${{ secrets.PAT_FOR_AUTO_REQUEST_REVIEW }}
          config: ./reviewers.yaml
          use_local: true

What is the permission required?

I already used "write-all", but my action still failed:

Run necojackarc/[email protected]
Fetching configuration file from the source branch
Fetching changed files in the pull request
Identifying reviewers based on the changed files
A "files" key does not exist in config; returning no reviewers for changed files.
Identifying reviewers based on the author
"per_author" is not set; returning no reviewers for the author.
Adding other group members to reviewers if group assignment feature is on
Group assignment feature is disabled
Matched no reviewers
Falling back to the default reviewers
Randomly picking reviewers if the number of reviewers is set
Requesting review to bluven
Error: HttpError: Resource not accessible by integration

Add condition according to label

Not sure if there's an alternative option

Would you be open a PR adding option to add reviewers according to labels?

Doesn't trigger the action when you open a PR not going through draft

The README suggests that you should use:

on:
  pull_request:
    types: [ready_for_review]

However, this doesn't trigger the action when you make a new PR without getting it to be a draft once.
Think about a better way to work on appropriate timings.

Possibly, we can add a new option - like ignore_draft.
At the same time, wouldn't it be nice to add ignored_keywords?

Migrate from CODEOWNERS to this format

would be nice to have a little tool to migrate codeowners entries to this yaml format

Handle GitHub usernames case-insensitively

As we found out in #31, you need to be careful about case sensitivity when you configure this GitHub Action.

Since GitHub usually handles usernames case-insensitively, it's more convenient to handle usernames in this action case-insensitively. What we need to do is probably:

• Lowercase usernames and group names in the config file
• Lowercase the author name

Once we do these things before any comparisons, we can handle them in a case-insensitive way.

Remove reviewer when PR is converted to draft

Sometimes a user incorrectly opens a PR in a ready for review state (not a draft). In such a situation the github action will assign a reviewer. If ignore_draft: true then can the reviewer be removed when the user converts the PR back to a draft?

Prevent merge if reviewers added did not accept the PR

One cool idea for this Github action is to ensure that the added reviewers (or at least one) approve the PR before it is merged. Are you considering that?

[CI] Add a test job to GitHub Actions

GitHub Actions, run:

• npm run lint
• npm run test

Please add support for configuration automatic assignment in addition to reviews

Hi. After much searching for an action that can automatically assign reviewers based on file globs, this seems like by far the best choice. However, my team's workflow actually hinges on utilizing assignment for "take another pass/work on this PR" rather than just reviewers. Might it be possible to extend this action's functionality to include a configuration for assigning & marking reviewers for folks that match the criteria to review a particular PR?

Per the code, I think I can go ahead and make this change if there's limited availability to work on the action but it will probably take me a few days before I can make the time for it.

Doesn't work if you work with fork-model

Run necojackarc/request-review-based-on-files@master
Fetch pull request and configuration
##[error]HttpError: No commit found for the ref test

bug: workflow fails on forks

I've set up the workflow to auto assign a github team, and it works great for native branches and PRs.

However for forks the workflow fails:

Run necojackarc/[email protected]
  with:
    config: .github/auto_request_review.yml
Fetching configuration file from the source branch
Error: Error: Parameter token or opts.auth is required

I assume this is a scope issue with the PAT, so I'm wondering the best way to handle it.

Currently I have the PAT set as a global secret in our github org since we want to use this workflow across several repos.

My guess is that the forks do not have scope access to the global org secrets. So that leaves two options that I can initially think of.

EDIT

1. Set the PAT at the repo level
2. Set the PAT on the forked repo

I'm not sure if this case has been worked through in the past, but would be interested in other's opinions while I debug this.

EDIT:
So the root of the issue is the lack of secret access on forks. There is the pull_request_target trigger, that was created to help with these types of workflows, when write access to the PR is needed from forks for non-security related actions. However I'm struggling to get the workflow to trigger at all now.

So the workflow on main needs to be updated for it to be triggered, so that is fixed. But I'm still getting the same error.

Error: Parameter token or opts.auth is required in PR opened by dependabot

In all PRs opened by dependabot, the action fails with this error

> Run necojackarc/[email protected]
  with:
    config: .github/reviewers.yml
Fetching configuration file from the source branch
Error: Error: Parameter token or opts.auth is required