Avoid duplicate comments on PR synchronize events

[Sultanyaron]

Description

When the review-pr action runs with the synchronize event, the augment agent posts multiple comments.

For example, if a PR has multiple commits pushed in sequence, the action may leave duplicate comments for essentially the same review message. This clutters the PR discussion and makes it harder to follow.

---

## .github/workflows/pr-review.yml

name: Auto-review PRs
on:
  pull_request:
    types: [opened, synchronize]
    branches: [main]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - name: Generate PR Review
        uses: augmentcode/review-pr@v0
        with:
          augment_session_auth: ${{ secrets.AUGMENT_SESSION_AUTH }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          pull_number: ${{ github.event.pull_request.number }}
          repo_name: ${{ github.repository }}

Steps to Reproduce

1. Open a PR.
2. Push multiple commits to the branch.
3. Observe that the review action posts multiple comments repeating the same content.

---

Expected Behavior

The action should avoid posting duplicate comments on synchronize events.

---

Proposed Solution

One possible solution is to follow the approach used by cursor bug-bot, which marks previous comments as outdated when a new one is posted.

This way, the PR conversation stays clean, and reviewers always see only the most relevant feedback.

---

Benefits

• 🧹 Prevents clutter in the PR discussion.
• 🎯 Keeps review feedback focused and easy to follow.
• 🔁 Aligns with established patterns in other review bots.

[anatoly-pashin-axon21]

Add a step before calling the review action:

      - name: Mark previous reviews as outdated
        uses: actions/github-script@v7
        with:
            script: |
                try {
                  const { owner, repo } = context.repo;
                  const pullNumber = context.payload.pull_request.number;

                  // Get all reviews with their minimized status using GraphQL
                  const reviewsQuery = `
                    query($owner: String!, $repo: String!, $pullNumber: Int!) {
                      repository(owner: $owner, name: $repo) {
                        pullRequest(number: $pullNumber) {
                          reviews(first: 100) {
                            nodes {
                              id
                              databaseId
                              state
                              isMinimized
                              author {
                                login
                              }
                            }
                          }
                        }
                      }
                    }
                  `;

                  const reviewsResult = await github.graphql(reviewsQuery, {
                    owner,
                    repo,
                    pullNumber
                  });

                  const allReviews = reviewsResult.repository.pullRequest.reviews.nodes;

                  // Filter for github-actions reviews that are not already minimized
                  const reviewsToMinimize = allReviews.filter(review =>
                    review.author?.login === 'github-actions' && !review.isMinimized
                  );

                  if (reviewsToMinimize.length === 0) {
                    console.log('No github-actions reviews need to be marked as outdated.');
                    return;
                  }

                  console.log(`Marking ${reviewsToMinimize.length} previous github-actions reviews as outdated...`);

                  // Mark each review as outdated
                  for (const review of reviewsToMinimize) {
                    try {
                      const mutation = `
                        mutation($subjectId: ID!) {
                          minimizeComment(input: {
                            subjectId: $subjectId,
                            classifier: OUTDATED
                          }) {
                            minimizedComment {
                              isMinimized
                            }
                          }
                        }
                      `;

                      await github.graphql(mutation, {
                        subjectId: review.id
                      });

                      console.log(`✓ Marked review #${review.databaseId} as outdated`);

                    } catch (reviewError) {
                      console.error(`✗ Failed to mark review #${review.databaseId} as outdated:`, reviewError.message);
                    }
                  }

                  console.log(`Completed processing ${reviewsToMinimize.length} reviews`);

                } catch (error) {
                  console.error('Error processing reviews:', error.message);
                  // Don't fail the workflow if marking reviews fails
                }