diff --git a/.github/workflows/bot.yml b/.github/workflows/bot.yml
new file mode 100644
index 00000000000..975f39f29dc
--- /dev/null
+++ b/.github/workflows/bot.yml
@@ -0,0 +1,79 @@
+name: GitHub Bot
+
+on:
+ # Watch for changes on PR state, assignees, labels, head branch and draft/ready status
+ pull_request_target:
+ types:
+ - assigned
+ - unassigned
+ - labeled
+ - unlabeled
+ - opened
+ - reopened
+ - synchronize # PR head updated
+ - converted_to_draft
+ - ready_for_review
+
+ # Watch for changes on PR comment
+ issue_comment:
+ types: [created, edited, deleted]
+
+ # Manual run from GitHub Actions interface
+ workflow_dispatch:
+ inputs:
+ pull-request-list:
+ description: "PR(s) to process: specify 'all' or a comma separated list of PR numbers, e.g. '42,1337,7890'"
+ required: true
+ default: all
+ type: string
+
+jobs:
+ # This job creates a matrix of PR numbers based on the inputs from the various
+ # events that can trigger this workflow so that the process-pr job below can
+ # handle the parallel processing of the pull-requests
+ define-prs-matrix:
+ name: Define PRs matrix
+ # Prevent bot from retriggering itself
+ if: ${{ github.actor != vars.GH_BOT_LOGIN }}
+ runs-on: ubuntu-latest
+ permissions:
+ pull-requests: read
+ outputs:
+ pr-numbers: ${{ steps.pr-numbers.outputs.pr-numbers }}
+
+ steps:
+ - name: Generate matrix from event
+ id: pr-numbers
+ working-directory: contribs/github-bot
+ env:
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ run: go run . matrix >> "$GITHUB_OUTPUT"
+
+ # This job processes each pull request in the matrix individually while ensuring
+ # that a same PR cannot be processed concurrently by mutliple runners
+ process-pr:
+ name: Process PR
+ needs: define-prs-matrix
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ # Run one job for each PR to process
+ pr-number: ${{ fromJSON(needs.define-prs-matrix.outputs.pr-numbers) }}
+ concurrency:
+ # Prevent running concurrent jobs for a given PR number
+ group: ${{ matrix.pr-number }}
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+
+ - name: Install Go
+ uses: actions/setup-go@v5
+ with:
+ go-version-file: go.mod
+
+ - name: Run GitHub Bot
+ working-directory: contribs/github-bot
+ env:
+ GITHUB_TOKEN: ${{ secrets.GH_BOT_PAT }}
+ run: go run . -pr-numbers '${{ matrix.pr-number }}' -verbose
diff --git a/contribs/github-bot/README.md b/contribs/github-bot/README.md
new file mode 100644
index 00000000000..e3cc12fe01a
--- /dev/null
+++ b/contribs/github-bot/README.md
@@ -0,0 +1,48 @@
+# GitHub Bot
+
+## Overview
+
+The GitHub Bot is designed to automate and streamline the process of managing pull requests. It can automate certain tasks such as requesting reviews, assigning users or applying labels, but it also ensures that certain requirements are satisfied before allowing a pull request to be merged. Interaction with the bot occurs through a comment on the pull request, providing all the information to the user and allowing them to check boxes for the manual validation of certain rules.
+
+## How It Works
+
+### Configuration
+
+The bot operates by defining a set of rules that are evaluated against each pull request passed as parameter. These rules are categorized into automatic and manual checks:
+
+- **Automatic Checks**: These are rules that the bot evaluates automatically. If a pull request meets the conditions specified in the rule, then the corresponding requirements are executed. For example, ensuring that changes to specific directories are reviewed by specific team members.
+- **Manual Checks**: These require human intervention. If a pull request meets the conditions specified in the rule, then a checkbox that can be checked only by specified teams is displayed on the bot comment. For example, determining if infrastructure needs to be updated based on changes to specific files.
+
+The bot configuration is defined in Go and is located in the file [config.go](./config.go).
+
+### GitHub Token
+
+For the bot to make requests to the GitHub API, it needs a Personal Access Token. The fine-grained permissions to assign to the token for the bot to function are:
+
+- `pull_requests` scope to read is the bare minimum to run the bot in dry-run mode
+- `pull_requests` scope to write to be able to update bot comment, assign user, apply label and request review
+- `contents` scope to read to be able to check if the head branch is up to date with another one
+- `commit_statuses` scope to write to be able to update pull request bot status check
+
+## Usage
+
+```bash
+> go install github.com/gnolang/gno/contribs/github-bot@latest
+// (go: downloading ...)
+
+> github-bot --help
+USAGE
+ github-bot [flags]
+
+This tool checks if the requirements for a PR to be merged are satisfied (defined in config.go) and displays PR status checks accordingly.
+A valid GitHub Token must be provided by setting the GITHUB_TOKEN environment variable.
+
+FLAGS
+ -dry-run=false print if pull request requirements are satisfied without updating anything on GitHub
+ -owner ... owner of the repo to process, if empty, will be retrieved from GitHub Actions context
+ -pr-all=false process all opened pull requests
+ -pr-numbers ... pull request(s) to process, must be a comma separated list of PR numbers, e.g '42,1337,7890'. If empty, will be retrieved from GitHub Actions context
+ -repo ... repo to process, if empty, will be retrieved from GitHub Actions context
+ -timeout 0s timeout after which the bot execution is interrupted
+ -verbose=false set logging level to debug
+```
diff --git a/contribs/github-bot/check.go b/contribs/github-bot/check.go
new file mode 100644
index 00000000000..8019246d27c
--- /dev/null
+++ b/contribs/github-bot/check.go
@@ -0,0 +1,246 @@
+package main
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "strings"
+ "sync"
+ "sync/atomic"
+
+ "github.com/gnolang/gno/contribs/github-bot/internal/client"
+ "github.com/gnolang/gno/contribs/github-bot/internal/logger"
+ p "github.com/gnolang/gno/contribs/github-bot/internal/params"
+ "github.com/gnolang/gno/contribs/github-bot/internal/utils"
+ "github.com/gnolang/gno/tm2/pkg/commands"
+ "github.com/google/go-github/v64/github"
+ "github.com/sethvargo/go-githubactions"
+ "github.com/xlab/treeprint"
+)
+
+func newCheckCmd() *commands.Command {
+ params := &p.Params{}
+
+ return commands.NewCommand(
+ commands.Metadata{
+ Name: "check",
+ ShortUsage: "github-bot check [flags]",
+ ShortHelp: "checks requirements for a pull request to be merged",
+ LongHelp: "This tool checks if the requirements for a pull request to be merged are satisfied (defined in config.go) and displays PR status checks accordingly.\nA valid GitHub Token must be provided by setting the GITHUB_TOKEN environment variable.",
+ },
+ params,
+ func(_ context.Context, _ []string) error {
+ params.ValidateFlags()
+ return execCheck(params)
+ },
+ )
+}
+
+func execCheck(params *p.Params) error {
+ // Create context with timeout if specified in the parameters.
+ ctx := context.Background()
+ if params.Timeout > 0 {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithTimeout(context.Background(), params.Timeout)
+ defer cancel()
+ }
+
+ // Init GitHub API client.
+ gh, err := client.New(ctx, params)
+ if err != nil {
+ return fmt.Errorf("comment update handling failed: %w", err)
+ }
+
+ // Get GitHub Actions context to retrieve comment update.
+ actionCtx, err := githubactions.Context()
+ if err != nil {
+ gh.Logger.Debugf("Unable to retrieve GitHub Actions context: %v", err)
+ return nil
+ }
+
+ // Handle comment update, if any.
+ if err := handleCommentUpdate(gh, actionCtx); errors.Is(err, errTriggeredByBot) {
+ return nil // Ignore if this run was triggered by a previous run.
+ } else if err != nil {
+ return fmt.Errorf("comment update handling failed: %w", err)
+ }
+
+ // Retrieve a slice of pull requests to process.
+ var prs []*github.PullRequest
+
+ // If requested, retrieve all open pull requests.
+ if params.PRAll {
+ prs, err = gh.ListPR(utils.PRStateOpen)
+ if err != nil {
+ return fmt.Errorf("unable to list all PR: %w", err)
+ }
+ } else {
+ // Otherwise, retrieve only specified pull request(s)
+ // (flag or GitHub Action context).
+ prs = make([]*github.PullRequest, len(params.PRNums))
+ for i, prNum := range params.PRNums {
+ pr, _, err := gh.Client.PullRequests.Get(gh.Ctx, gh.Owner, gh.Repo, prNum)
+ if err != nil {
+ return fmt.Errorf("unable to retrieve specified pull request (%d): %w", prNum, err)
+ }
+ prs[i] = pr
+ }
+ }
+
+ return processPRList(gh, prs)
+}
+
+func processPRList(gh *client.GitHub, prs []*github.PullRequest) error {
+ if len(prs) > 1 {
+ prNums := make([]int, len(prs))
+ for i, pr := range prs {
+ prNums[i] = pr.GetNumber()
+ }
+
+ gh.Logger.Infof("%d pull requests to process: %v\n", len(prNums), prNums)
+ }
+
+ // Process all pull requests in parallel.
+ autoRules, manualRules := config(gh)
+ var wg sync.WaitGroup
+
+ // Used in dry-run mode to log cleanly from different goroutines.
+ logMutex := sync.Mutex{}
+
+ // Used in regular-run mode to return an error if one PR processing failed.
+ var failed atomic.Bool
+
+ for _, pr := range prs {
+ wg.Add(1)
+ go func(pr *github.PullRequest) {
+ defer wg.Done()
+ commentContent := CommentContent{}
+ commentContent.allSatisfied = true
+
+ // Iterate over all automatic rules in config.
+ for _, autoRule := range autoRules {
+ ifDetails := treeprint.NewWithRoot(fmt.Sprintf("%s Condition met", utils.Success))
+
+ // Check if conditions of this rule are met by this PR.
+ if !autoRule.ifC.IsMet(pr, ifDetails) {
+ continue
+ }
+
+ c := AutoContent{Description: autoRule.description, Satisfied: false}
+ thenDetails := treeprint.NewWithRoot(fmt.Sprintf("%s Requirement not satisfied", utils.Fail))
+
+ // Check if requirements of this rule are satisfied by this PR.
+ if autoRule.thenR.IsSatisfied(pr, thenDetails) {
+ thenDetails.SetValue(fmt.Sprintf("%s Requirement satisfied", utils.Success))
+ c.Satisfied = true
+ } else {
+ commentContent.allSatisfied = false
+ }
+
+ c.ConditionDetails = ifDetails.String()
+ c.RequirementDetails = thenDetails.String()
+ commentContent.AutoRules = append(commentContent.AutoRules, c)
+ }
+
+ // Retrieve manual check states.
+ checks := make(map[string]manualCheckDetails)
+ if comment, err := gh.GetBotComment(pr.GetNumber()); err == nil {
+ checks = getCommentManualChecks(comment.GetBody())
+ }
+
+ // Iterate over all manual rules in config.
+ for _, manualRule := range manualRules {
+ ifDetails := treeprint.NewWithRoot(fmt.Sprintf("%s Condition met", utils.Success))
+
+ // Check if conditions of this rule are met by this PR.
+ if !manualRule.ifC.IsMet(pr, ifDetails) {
+ continue
+ }
+
+ // Get check status from current comment, if any.
+ checkedBy := ""
+ check, ok := checks[manualRule.description]
+ if ok {
+ checkedBy = check.checkedBy
+ }
+
+ commentContent.ManualRules = append(
+ commentContent.ManualRules,
+ ManualContent{
+ Description: manualRule.description,
+ ConditionDetails: ifDetails.String(),
+ CheckedBy: checkedBy,
+ Teams: manualRule.teams,
+ },
+ )
+
+ if checkedBy == "" {
+ commentContent.allSatisfied = false
+ }
+ }
+
+ // Logs results or write them in bot PR comment.
+ if gh.DryRun {
+ logMutex.Lock()
+ logResults(gh.Logger, pr.GetNumber(), commentContent)
+ logMutex.Unlock()
+ } else {
+ if err := updatePullRequest(gh, pr, commentContent); err != nil {
+ gh.Logger.Errorf("unable to update pull request: %v", err)
+ failed.Store(true)
+ }
+ }
+ }(pr)
+ }
+ wg.Wait()
+
+ if failed.Load() {
+ return errors.New("error occurred while processing pull requests")
+ }
+
+ return nil
+}
+
+// logResults is called in dry-run mode and outputs the status of each check
+// and a conclusion.
+func logResults(logger logger.Logger, prNum int, commentContent CommentContent) {
+ logger.Infof("Pull request #%d requirements", prNum)
+ if len(commentContent.AutoRules) > 0 {
+ logger.Infof("Automated Checks:")
+ }
+
+ for _, rule := range commentContent.AutoRules {
+ status := utils.Fail
+ if rule.Satisfied {
+ status = utils.Success
+ }
+ logger.Infof("%s %s", status, rule.Description)
+ logger.Debugf("If:\n%s", rule.ConditionDetails)
+ logger.Debugf("Then:\n%s", rule.RequirementDetails)
+ }
+
+ if len(commentContent.ManualRules) > 0 {
+ logger.Infof("Manual Checks:")
+ }
+
+ for _, rule := range commentContent.ManualRules {
+ status := utils.Fail
+ checker := "any user with comment edit permission"
+ if rule.CheckedBy != "" {
+ status = utils.Success
+ }
+ if len(rule.Teams) == 0 {
+ checker = fmt.Sprintf("a member of one of these teams: %s", strings.Join(rule.Teams, ", "))
+ }
+ logger.Infof("%s %s", status, rule.Description)
+ logger.Debugf("If:\n%s", rule.ConditionDetails)
+ logger.Debugf("Can be checked by %s", checker)
+ }
+
+ logger.Infof("Conclusion:")
+ if commentContent.allSatisfied {
+ logger.Infof("%s All requirements are satisfied\n", utils.Success)
+ } else {
+ logger.Infof("%s Not all requirements are satisfied\n", utils.Fail)
+ }
+}
diff --git a/contribs/github-bot/comment.go b/contribs/github-bot/comment.go
new file mode 100644
index 00000000000..8bf4a158745
--- /dev/null
+++ b/contribs/github-bot/comment.go
@@ -0,0 +1,282 @@
+package main
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "regexp"
+ "strings"
+ "text/template"
+
+ "github.com/gnolang/gno/contribs/github-bot/internal/client"
+ "github.com/gnolang/gno/contribs/github-bot/internal/utils"
+
+ "github.com/google/go-github/v64/github"
+ "github.com/sethvargo/go-githubactions"
+)
+
+var errTriggeredByBot = errors.New("event triggered by bot")
+
+// Compile regex only once.
+var (
+ // Regex for capturing the entire line of a manual check.
+ manualCheckLine = regexp.MustCompile(`(?m:^-\s\[([ xX])\]\s+(.+?)\s*(\(checked by @(\w+)\))?$)`)
+ // Regex for capturing only the checkboxes.
+ checkboxes = regexp.MustCompile(`(?m:^- \[[ x]\])`)
+ // Regex used to capture markdown links.
+ markdownLink = regexp.MustCompile(`\[(.*)\]\(.*\)`)
+)
+
+// These structures contain the necessary information to generate
+// the bot's comment from the template file.
+type AutoContent struct {
+ Description string
+ Satisfied bool
+ ConditionDetails string
+ RequirementDetails string
+}
+type ManualContent struct {
+ Description string
+ CheckedBy string
+ ConditionDetails string
+ Teams []string
+}
+type CommentContent struct {
+ AutoRules []AutoContent
+ ManualRules []ManualContent
+ allSatisfied bool
+}
+
+type manualCheckDetails struct {
+ status string
+ checkedBy string
+}
+
+// getCommentManualChecks parses the bot comment to get the checkbox status,
+// the check description and the username who checked it.
+func getCommentManualChecks(commentBody string) map[string]manualCheckDetails {
+ checks := make(map[string]manualCheckDetails)
+
+ // For each line that matches the "Manual check" regex.
+ for _, match := range manualCheckLine.FindAllStringSubmatch(commentBody, -1) {
+ description := match[2]
+ status := match[1]
+ checkedBy := ""
+ if len(match) > 4 {
+ checkedBy = strings.ToLower(match[4]) // if X captured, convert it to x.
+ }
+
+ checks[description] = manualCheckDetails{status: status, checkedBy: checkedBy}
+ }
+
+ return checks
+}
+
+// handleCommentUpdate checks if:
+// - the current run was triggered by GitHub Actions
+// - the triggering event is an edit of the bot comment
+// - the comment was not edited by the bot itself (prevent infinite loop)
+// - the comment change is only a checkbox being checked or unckecked (or restore it)
+// - the actor / comment editor has permission to modify this checkbox (or restore it)
+func handleCommentUpdate(gh *client.GitHub, actionCtx *githubactions.GitHubContext) error {
+ // Ignore if it's not a comment related event.
+ if actionCtx.EventName != utils.EventIssueComment {
+ gh.Logger.Debugf("Event is not issue comment related (%s)", actionCtx.EventName)
+ return nil
+ }
+
+ // Ignore if the action type is not deleted or edited.
+ actionType, ok := actionCtx.Event["action"].(string)
+ if !ok {
+ return errors.New("unable to get type on issue comment event")
+ }
+
+ if actionType != "deleted" && actionType != "edited" {
+ return nil
+ }
+
+ // Return if comment was edited by bot (current authenticated user).
+ authUser, _, err := gh.Client.Users.Get(gh.Ctx, "")
+ if err != nil {
+ return fmt.Errorf("unable to get authenticated user: %w", err)
+ }
+
+ if actionCtx.Actor == authUser.GetLogin() {
+ gh.Logger.Debugf("Prevent infinite loop if the bot comment was edited by the bot itself")
+ return errTriggeredByBot
+ }
+
+ // Get login of the author of the edited comment.
+ login, ok := utils.IndexMap(actionCtx.Event, "comment", "user", "login").(string)
+ if !ok {
+ return errors.New("unable to get comment user login on issue comment event")
+ }
+
+ // If the author is not the bot, return.
+ if login != authUser.GetLogin() {
+ return nil
+ }
+
+ // Get comment updated body.
+ current, ok := utils.IndexMap(actionCtx.Event, "comment", "body").(string)
+ if !ok {
+ return errors.New("unable to get comment body on issue comment event")
+ }
+
+ // Get comment previous body.
+ previous, ok := utils.IndexMap(actionCtx.Event, "changes", "body", "from").(string)
+ if !ok {
+ return errors.New("unable to get changes body content on issue comment event")
+ }
+
+ // Get PR number from GitHub Actions context.
+ prNum, ok := utils.IndexMap(actionCtx.Event, "issue", "number").(float64)
+ if !ok || prNum <= 0 {
+ return errors.New("unable to get issue number on issue comment event")
+ }
+
+ // Check if change is only a checkbox being checked or unckecked.
+ if checkboxes.ReplaceAllString(current, "") != checkboxes.ReplaceAllString(previous, "") {
+ // If not, restore previous comment body.
+ if !gh.DryRun {
+ gh.SetBotComment(previous, int(prNum))
+ }
+ return errors.New("bot comment edited outside of checkboxes")
+ }
+
+ // Check if actor / comment editor has permission to modify changed boxes.
+ currentChecks := getCommentManualChecks(current)
+ previousChecks := getCommentManualChecks(previous)
+ edited := ""
+ for key := range currentChecks {
+ // If there is no diff for this check, ignore it.
+ if currentChecks[key].status == previousChecks[key].status {
+ continue
+ }
+
+ // Get teams allowed to edit this box from config.
+ var teams []string
+ found := false
+ _, manualRules := config(gh)
+
+ for _, manualRule := range manualRules {
+ if manualRule.description == key {
+ found = true
+ teams = manualRule.teams
+ }
+ }
+
+ // If rule were not found, return to reprocess the bot comment entirely
+ // (maybe bot config was updated since last run?).
+ if !found {
+ gh.Logger.Debugf("Updated rule not found in config: %s", key)
+ return nil
+ }
+
+ // If teams specified in rule, check if actor is a member of one of them.
+ if len(teams) > 0 {
+ if gh.IsUserInTeams(actionCtx.Actor, teams) {
+ if !gh.DryRun {
+ gh.SetBotComment(previous, int(prNum))
+ }
+ return errors.New("checkbox edited by a user not allowed to")
+ }
+ }
+
+ // This regex capture only the line of the current check.
+ specificManualCheck := regexp.MustCompile(fmt.Sprintf(`(?m:^- \[%s\] %s.*$)`, currentChecks[key].status, regexp.QuoteMeta(key)))
+
+ // If the box is checked, append the username of the user who checked it.
+ if strings.TrimSpace(currentChecks[key].status) == "x" {
+ replacement := fmt.Sprintf("- [%s] %s (checked by @%s)", currentChecks[key].status, key, actionCtx.Actor)
+ edited = specificManualCheck.ReplaceAllString(current, replacement)
+ } else {
+ // Else, remove the username of the user.
+ replacement := fmt.Sprintf("- [%s] %s", currentChecks[key].status, key)
+ edited = specificManualCheck.ReplaceAllString(current, replacement)
+ }
+ }
+
+ // Update comment with username.
+ if edited != "" && !gh.DryRun {
+ gh.SetBotComment(edited, int(prNum))
+ gh.Logger.Debugf("Comment manual checks updated successfully")
+ }
+
+ return nil
+}
+
+// generateComment generates a comment using the template file and the
+// content passed as parameter.
+func generateComment(content CommentContent) (string, error) {
+ // Custom function to strip markdown links.
+ funcMap := template.FuncMap{
+ "stripLinks": func(input string) string {
+ return markdownLink.ReplaceAllString(input, "$1")
+ },
+ }
+
+ // Bind markdown stripping function to template generator.
+ const tmplFile = "comment.tmpl"
+ tmpl, err := template.New(tmplFile).Funcs(funcMap).ParseFiles(tmplFile)
+ if err != nil {
+ return "", fmt.Errorf("unable to init template: %w", err)
+ }
+
+ // Generate bot comment using template file.
+ var commentBytes bytes.Buffer
+ if err := tmpl.Execute(&commentBytes, content); err != nil {
+ return "", fmt.Errorf("unable to execute template: %w", err)
+ }
+
+ return commentBytes.String(), nil
+}
+
+// updatePullRequest updates or creates both the bot comment and the commit status.
+func updatePullRequest(gh *client.GitHub, pr *github.PullRequest, content CommentContent) error {
+ // Generate comment text content.
+ commentText, err := generateComment(content)
+ if err != nil {
+ return fmt.Errorf("unable to generate comment on PR %d: %w", pr.GetNumber(), err)
+ }
+
+ // Update comment on pull request.
+ comment, err := gh.SetBotComment(commentText, pr.GetNumber())
+ if err != nil {
+ return fmt.Errorf("unable to update comment on PR %d: %w", pr.GetNumber(), err)
+ } else {
+ gh.Logger.Infof("Comment successfully updated on PR %d", pr.GetNumber())
+ }
+
+ // Prepare commit status content.
+ var (
+ context = "Merge Requirements"
+ targetURL = comment.GetHTMLURL()
+ state = "failure"
+ description = "Some requirements are not satisfied yet. See bot comment."
+ )
+
+ if content.allSatisfied {
+ state = "success"
+ description = "All requirements are satisfied."
+ }
+
+ // Update or create commit status.
+ if _, _, err := gh.Client.Repositories.CreateStatus(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ pr.GetHead().GetSHA(),
+ &github.RepoStatus{
+ Context: &context,
+ State: &state,
+ TargetURL: &targetURL,
+ Description: &description,
+ }); err != nil {
+ return fmt.Errorf("unable to create status on PR %d: %w", pr.GetNumber(), err)
+ } else {
+ gh.Logger.Infof("Commit status successfully updated on PR %d", pr.GetNumber())
+ }
+
+ return nil
+}
diff --git a/contribs/github-bot/comment.tmpl b/contribs/github-bot/comment.tmpl
new file mode 100644
index 00000000000..ebd07fdd4b9
--- /dev/null
+++ b/contribs/github-bot/comment.tmpl
@@ -0,0 +1,51 @@
+# Merge Requirements
+
+The following requirements must be fulfilled before a pull request can be merged.
+Some requirement checks are automated and can be verified by the CI, while others need manual verification by a staff member.
+
+These requirements are defined in this [configuration file](https://github.com/GnoCheckBot/demo/blob/main/config.go).
+
+## Automated Checks
+
+{{ range .AutoRules }} {{ if .Satisfied }}🟢{{ else }}🔴{{ end }} {{ .Description }}
+{{ end }}
+
+{{ if .AutoRules }}Details
+{{ range .AutoRules }}
+{{ .Description | stripLinks }}
+
+### If
+```
+{{ .ConditionDetails | stripLinks }}
+```
+### Then
+```
+{{ .RequirementDetails | stripLinks }}
+```
+
Details
+{{ range .ManualRules }}
+{{ .Description | stripLinks }}
+
+### If
+```
+{{ .ConditionDetails }}
+```
+### Can be checked by
+{{range $item := .Teams }} - team {{ $item | stripLinks }}
+{{ else }}
+- Any user with comment edit permission
+{{end}}
+