[Intermediate]: Create a workflow for PRs labelled 'Good First Issue' or 'Beginner' to request review from triage

[exploreriii]

🧩 Intermediate Contributors

This issue is intended for contributors who already have some familiarity with the
Hiero Python SDK codebase and contribution workflow.

You should feel comfortable:

• navigating existing source code and examples
• understanding SDK concepts without step-by-step guidance
• following the standard PR workflow without additional onboarding

If this is your very first contribution to the project, we recommend starting with a few
Good First Issues before working on this one.

🐞 Problem Description

Currently, our PRs are requesting automatic reviews based on code ownership, which means committers and maintainers.

We have triage members that are Junior Committers.
These are committers in training, so, they can do the same tasks of a committer but only have read-only priviledges, not write.

As a result of the way the SDK is structured, junior committers are not being asked for reviews automatically, but will benefit a lot from building their review skills.

💡 Expected Solution

My proposal is to if a PULL REQUEST is labelled 'Good First Issue' or 'Beginner' it automatically posts a comment to request feedback from a random member in the triage community.

🧠 Implementation Notes

To do this, we need to see
@hiero-ledger/hiero-sdk-python-triage members

write this in .github
as triage-members.txt

use this list to request a review to a PR from one of these members, randomly

Only for 'Good First Issues' or 'beginner' issues

Triage members will not be requested for intermediate or advanced issues

Currently, the bot should COMMENT on the PR and say something along the lines of:
Hi X, thank you for marking this BEGINNER/GFI pull request as ready for review. We have assigned NAME to provide an initial review, and once approved, it will be passed on to a committer or maintainer to review.

NOTE: it should not assign a reviewer - that is currently out of scope as conflicts with other bots - it should just comment and CC the triage member

✅ Acceptance Criteria

To merge this issue, the pull request must:

• Fully address the problem described above
• Follow existing project conventions and patterns
• Include tests or example updates where appropriate
• Pass all CI checks
• Include a valid changelog entry
• be a DCO and GPG key signed as git commit -S -s -m "chore: my change" with a GPG key set up

📚 Additional Context or Resources

• SDK Developer Docs
• SDK Developer Training

[github-actions]

@coderabbitai plan

[coderabbitai]

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Fetch details of issue `#1721`
gh issue view 1721 --json title,body,labels,author,assignees,comments --jq '{title: .title, body: .body, labels: .labels[].name, author: .author.login, assignees: .assignees[].login, comments: .comments[] | {author: .author.login, body: .body}}'

Length of output: 0

---

🏁 Script executed:

#!/bin/bash
# Fetch details of issue `#1721` with simpler command
gh issue view 1721 --json title,body,labels,author

echo "---"
echo "Comments:"
gh issue view 1721 --json comments --jq '.comments[] | "Author: \(.author.login)\nBody: \(.body)\n---"'

Length of output: 2817

---

🏁 Script executed:

#!/bin/bash
# Check existing GitHub workflows to understand patterns
echo "=== Listing existing workflows ==="
ls -la .github/workflows/ 2>/dev/null || echo "No workflows directory found"

echo -e "\n=== Checking for existing label-triggered workflows ==="
if [ -d .github/workflows ]; then
    fd -e yml -e yaml . .github/workflows/ --exec grep -l "labeled" {} \;
fi

echo -e "\n=== Checking .github directory structure ==="
tree -L 2 .github/ 2>/dev/null || find .github/ -maxdepth 2 -type f 2>/dev/null

echo -e "\n=== Checking if triage team exists ==="
gh api /orgs/hiero-ledger/teams/hiero-sdk-python-triage 2>/dev/null || echo "Team info not accessible or doesn't exist"

Length of output: 5459

---

🏁 Script executed:

#!/bin/bash
# Check existing label-triggered workflows for patterns
echo "=== bot-gfi-candidate-notification.yaml ==="
cat .github/workflows/bot-gfi-candidate-notification.yaml

echo -e "\n=== bot-intermediate-assignment.yml ==="
cat .github/workflows/bot-intermediate-assignment.yml

echo -e "\n=== Checking mentor_roster.json structure ==="
cat .github/mentor_roster.json

echo -e "\n=== Check one of the JS scripts for pattern ==="
head -50 .github/scripts/bot-intermediate-assignment.js

Length of output: 5161

---

@github-actions I'll create a plan to implement the workflow for automatically requesting reviews from triage members on beginner PRs.

Task: Create workflow to request triage member reviews on beginner PRs

Based on the issue requirements and existing workflow patterns in the repository, here's the implementation plan:

Overview

• Create a GitHub Actions workflow that triggers when a PR is labeled "Good First Issue" or "Beginner"
• Randomly select a triage member from a predefined list
• Post a comment requesting their review/feedback
• Follow existing project conventions for bot workflows

Components to Create

1. .github/triage-members.txt - List of triage team members
2. .github/workflows/bot-triage-review-request.yml - Workflow definition
3. .github/scripts/bot-triage-review-request.js - Logic implementation
4. Changelog entry

---

"

    uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd  `#v8.0.0`
    with:
      script: |
        const script = require('./.github/scripts/bot-triage-review-request.js');
        await script({ github, context });

</requirement> -->

<!-- <requirement>
[requirement create_triage_workflow_3/4 create_script_file]
Create the JavaScript implementation that reads triage members, randomly selects one, and posts a review request comment.

Following patterns from `bot-intermediate-assignment.js` and `bot-gfi-candidate-notification.js`:

**File: `.github/scripts/bot-triage-review-request.js`**
```javascript
const fs = require('fs');
const path = require('path');

const COMMENT_MARKER = process.env.COMMENT_MARKER || '<!-- Triage Review Request -->';
const TRIAGE_MEMBERS_FILE = process.env.TRIAGE_MEMBERS_FILE || '.github/triage-members.txt';
const DRY_RUN = /^true$/i.test(process.env.DRY_RUN || '');

/**
 * Read triage members from file
 * `@returns` {string[]} Array of GitHub usernames
 */
function readTriageMembers() {
  try {
    const filePath = path.resolve(TRIAGE_MEMBERS_FILE);
    const content = fs.readFileSync(filePath, 'utf8');
    
    // Parse file: one username per line, ignore comments and empty lines
    const members = content
      .split('\n')
      .map(line => line.trim())
      .filter(line => line && !line.startsWith('#'))
      .filter(username => /^[a-zA-Z0-9-]+$/.test(username)); // Valid GitHub username format
    
    return members;
  } catch (error) {
    console.error(`Error reading triage members file: ${error.message}`);
    return [];
  }
}

/**
 * Select a random member from the list
 * `@param` {string[]} members - Array of usernames
 * `@returns` {string|null} Selected username or null if empty
 */
function selectRandomMember(members) {
  if (!members || members.length === 0) {
    return null;
  }
  const randomIndex = Math.floor(Math.random() * members.length);
  return members[randomIndex];
}

/**
 * Check if we already commented on this PR
 * `@param` {object} github - GitHub API client
 * `@param` {object} context - GitHub Actions context
 * `@returns` {Promise<boolean>} True if comment exists
 */
async function hasExistingComment(github, context) {
  try {
    const { data: comments } = await github.rest.issues.listComments({
      owner: context.repo.owner,
      repo: context.repo.repo,
      issue_number: context.payload.pull_request.number,
    });

    return comments.some(comment => comment.body?.includes(COMMENT_MARKER));
  } catch (error) {
    console.error(`Error checking existing comments: ${error.message}`);
    return false;
  }
}

/**
 * Main function
 */
module.exports = async ({ github, context }) => {
  console.log('=== Triage Review Request Bot ===');
  console.log(`DRY_RUN mode: ${DRY_RUN}`);
  console.log(`PR #${context.payload.pull_request.number}`);
  console.log(`Labels: ${context.payload.pull_request.labels.map(l => l.name).join(', ')}`);

  // Read triage members
  const triageMembers = readTriageMembers();
  console.log(`Found ${triageMembers.length} triage members`);

  if (triageMembers.length === 0) {
    console.log('No triage members found in file. Exiting.');
    return;
  }

  // Check if we already commented
  const alreadyCommented = await hasExistingComment(github, context);
  if (alreadyCommented) {
    console.log('Already requested review on this PR. Skipping.');
    return;
  }

  // Select random member
  const selectedMember = selectRandomMember(triageMembers);
  console.log(`Selected triage member: ${selectedMember}`);

  // Prepare comment
  const commentBody = `${COMMENT_MARKER}
👋 Hi @${selectedMember}!

This PR has been labeled as a **Good First Issue** or **Beginner** contribution. As a member of our triage team, we'd appreciate your review and feedback to help the contributor improve their work.

**Your review will help:**
- Build your code review skills
- Support new contributors
- Ensure quality standards are met

Feel free to provide constructive feedback, ask questions, or suggest improvements. Thank you for helping our community grow! 🚀`;

  console.log('Comment to post:');
  console.log(commentBody);

  if (DRY_RUN) {
    console.log('DRY_RUN mode enabled. Not posting comment.');
    return;
  }

  // Post comment
  try {
    await github.rest.issues.createComment({
      owner: context.repo.owner,
      repo: context.repo.repo,
      issue_number: context.payload.pull_request.number,
      body: commentBody,
    });
    console.log('✅ Comment posted successfully');
  } catch (error) {
    console.error(`Error posting comment: ${error.message}`);
    throw error;
  }
};

-->

Testing Considerations

Since this is a GitHub Actions workflow, traditional unit tests are limited. However, testing can include:

1. Manual Testing:

   • Create a test PR and label it with "Good First Issue"
   • Verify a comment is posted with a random triage member tagged
   • Verify no duplicate comments are posted when re-labeled
   • Test with "Beginner" label as well

2. Dry Run Testing:

   • The workflow includes DRY_RUN mode that activates for non-hiero-ledger forks
   • Can be tested in a fork before merging

3. Script Validation:

   • The JavaScript can be tested locally with Node.js
   • Verify file parsing, random selection, and comment generation logic

Additional Notes

• The workflow will only trigger on PRs, not issues (uses pull_request event)
• It checks for existing comments to avoid duplicates
• Triage members file must be manually populated with actual usernames
• DRY_RUN mode prevents accidental execution in forks or testing environments
• Follows all existing security patterns (step-security/harden-runner)
• Uses same action versions as other workflows for consistency

---

🏁 Script executed:

#!/bin/bash
# Find the changelog file
echo "Looking for changelog file..."
fd -i changelog -t f | head -5

Length of output: 141

---

🏁 Script executed:

#!/bin/bash
# Check the CHANGELOG.md format to ensure correct entry format
echo "=== CHANGELOG.md format (first 50 lines) ==="
head -50 CHANGELOG.md

echo -e "\n=== Checking changelog entry documentation ==="
cat docs/sdk_developers/changelog_entry.md

Length of output: 8554

---

Perfect! Now I have all the information needed. Here's the complete implementation plan:

---

📋 Implementation Plan Summary

This plan will create a new GitHub Actions workflow that automatically requests reviews from triage team members when a PR is labeled as "Good First Issue" or "Beginner". This helps junior committers build their review skills while supporting new contributors.

Components to Create:

1. .github/triage-members.txt - File containing triage team member usernames (one per line)
2. .github/workflows/bot-triage-review-request.yml - Workflow that triggers on PR label events
3. .github/scripts/bot-triage-review-request.js - JavaScript implementation for random selection and comment posting
4. CHANGELOG.md - Add entry under [Unreleased] → Added section

Key Features:

✅ Triggers only on "Good First Issue" or "Beginner" labeled PRs
✅ Randomly selects one triage member from the list
✅ Prevents duplicate comments on the same PR
✅ Follows existing security patterns (harden-runner)
✅ Includes DRY_RUN mode for safe testing
✅ Uses consistent action versions with other workflows

Post-Implementation Steps:

1. Populate triage members: Maintainers need to add actual GitHub usernames to .github/triage-members.txt
2. Manual testing: Create a test PR, label it, and verify the comment appears
3. Monitor: Check that only one comment is posted and it tags the correct user

---

The updated changelog entry requirement is now complete with the proper format. All requirements are ready for implementation! 🚀

---

💡 Use @coderabbitai plan to create a plan for code changes

[AkshayKumarSahu]

/assign

[github-actions]

Hi @AkshayKumarSahu, this is the Assignment Bot.

Assigning you to this issue would exceed the limit of 2 open assignments.

Please resolve and merge your existing assigned issues before requesting new ones.

[exploreriii]

Hi @AkshayKumarSahu working hard to review and merge a PR, then will aim to assign you 👍 For now you have exceeded the limit

Appreciate your patience

[exploreriii]

Hi @AkshayKumarSahu your PRs are approved and I am blocked from merging them, so please consider yourself assigned to this and good luck!
I will formally assign you as soon as I can merge your PRs - thank you for your patience

Please follow best practices, here is a nice example https://github.com/hiero-ledger/hiero-sdk-cpp/blob/7fa1993a0e65bd95e020835db8c1637149011208/.github/scripts/bot-assign-on-comment.js
we have many examples in .github/workflows and .github/scripts, but they can be refined by avoiding hard coding and etc