Refactor Good First Issue label handling across .github workflows and scripts

[cheese-cakee]

🧑‍💻 Intermediate Issue

Welcome! This is an Intermediate Issue touching core repo automation reliability.

🏁 When this issue is complete, you will have:

✅ Removed inconsistent hardcoded Good First Issue label checks across automation
✅ Centralized label handling so future renames are low-risk
✅ Added verification for workflow/script behavior in real issue/PR scenarios
✅ Delivered a clean, review-ready PR with evidence

🐞 Problem Description

Good First Issue label handling is currently inconsistent across .github automation:

• Some logic uses exact "Good First Issue"
• Some logic uses lowercase "good first issue"
• Some logic already includes fallback forms in search queries (e.g. "skill: good first issue")

Because label checks are split and inconsistent, automation can silently drift or misfire (assignment gating, recommendation bots, spam-list updates, etc.) when labels or matching logic evolve.

This issue matters because these bots directly affect contributor onboarding and maintainer triage workload. Inconsistent label logic creates avoidable operational noise and review burden.

💡 Expected Solution

Refactor Good First Issue label usage to a consistent, centralized pattern across relevant .github scripts/workflows, so behavior is reliable today and easy to update in one place later.

The expected outcome is: no behavior regressions, cleaner label matching, and future-proofing for possible label naming updates.

🔍 Background Research

Investigate these files first (primary scope):

• .github/scripts/bot-gfi-assign-on-comment.js
• .github/scripts/bot-assignment-check.sh
• .github/scripts/bot-next-issue-recommendation.js
• .github/scripts/update-spam-list.js
• .github/workflows/bot-intermediate-assignment.yml (uses GFI env)
• .github/ISSUE_TEMPLATE/02_good_first_issue.yml (canonical reference for current label)

Related recent refactor pattern to follow:

• Issue: Refactor beginner, intermediate, advanced labels #2131
• PR: Refactor: beginner, intermediate, advanced labels #2170

Reference docs:

• Contribution workflow: docs/sdk_developers/workflow.md
• Testing guide: docs/sdk_developers/testing.md

🛠️ Implementation Notes

• Treat this as sensitive automation work; avoid broad unrelated refactors.
• Keep scope focused to Good First Issue label handling only.
• Centralize label constants in shared script config (or equivalent single source of truth).
• Ensure comparisons are intentionally case-handled where needed.
• Preserve current expected behavior for existing label(s); do not break active contributor flows.
• If adding fallback support (e.g., alternate label forms), document it clearly.
• Exclude archived workflows/scripts unless directly required for active behavior.

🔬 Technical Domains

• Intermediate to Advanced Programming (automation logic across scripts/workflows)
• File Specific Knowledge (.github/scripts + workflow gates)
• Backward Compatibility (do not break existing issue/assignment flows)
• Protobuf Alignment
• Testing (workflow behavior + script-level verification)

🧠 Intermediate Contributors — Prerequisites & Expectations

Caution

Intermediate issues are high-risk. We expect more than just a 'working solution' and will recommend beginner issues if the PR does not meet these standards.

🏁 Concrete Prerequisites

• Advanced Programming Language: Higher level intermediate or advanced programming language.
• Expertise: Strong understanding of files related to this issue (research before claiming!).
• Proven History: Successfully completed ≥ 5 beginner issues in this repo.

Note

CI/CD Exception: For issues focused on GitHub Actions / Workflows, the repo-specific thresholds above may be waived if the contributor demonstrates intermediate-level proficiency in CI/CD.

If this feels like too big a step, that is completely fine — try a beginner issue first or a different intermediate issue first. You can always come back when you are ready.

⚠️ AI Usage Policy

• Using AI to generate code for Intermediate issues is strictly discouraged.
• Using AI as the main source of research is strictly discouraged; refer to language and library documentation, protobuf definitions, and other SDKs.

⏱️ Timeline & Workflow

• Typical time: ~2 weeks / ~25 hours.
• Completing an intermediate issue in 1–3 days is a red flag.

Tip

Suggested: share your proposed implementation approach as a comment before writing code to get early feedback and avoid wasted effort.

🧪 Testing Requirements

For this issue (workflow/script changes), include:

• Script-level validation for changed paths (targeted tests where present)
• Fork-based end-to-end verification:
  1. Create/open a test issue with Good First Issue label
  2. Trigger relevant bot path(s) (/assign, assignment guard, recommendation flow)
  3. Capture expected comments/assignment behavior
• Link evidence in PR:
  • test issue URLs
  • workflow run URLs
  • brief before/after behavior notes

All CI checks must pass before requesting review.

🛡️ Quality & Review Standards

Intermediate PRs must be working, maintainable, and aligned with SDK architecture.

1. Working: The implementation must solve the problem and meet the acceptance criteria.
2. Maintainable: Code should be clear and concise enough for others to understand and debug without your assistance.
3. SDK Alignment: The solution should fit well with existing SDK patterns and abstractions.
4. Backward Compatibility: Public API signatures must be preserved.
5. Comprehensive Testing: Must include unit and integration tests covering all new logic paths, edge cases, and failure modes.

⚠️ Breaking changes

• Before changing any function signature, return type, or public API — stop and check.
• If a breaking change is unavoidable: get explicit maintainer approval before implementing.
• All existing tests should pass as-is.

✅ PR Quality Checklist

Before opening your PR, confirm:

• I have spent the majority of my time researching the problem and solution space extensively, including reviewing relevant code, documentation, and external resources.
• My implementation works but is also of high quality, including maintainability, readability, and architectural fit.
• I have checked for breaking changes; no public APIs regress.
• The system design fits with current Hiero SDK architectural approaches.
• Every line of code is personally understood and explainable.

Before requesting a review, confirm:

• I have reviewed the diff line by line.
• My implementation fully addresses the problem described above.
• I did not modify files unrelated to this issue.
• Clean git history — no rebase artifacts, merge commits, or unrelated files.
• My commits are signed: git commit -S -s -m "chore: description".
• I have applied appropriate linting, code quality, and formatting tools used in this repo.
• I have included appropriate tests and all CI checks pass.

📋 Workflow quick reference

You know the workflow — here are the links if you need them:

Step	Guide
Claim this issue	Comment /assign below
Sync with main	https://github.com/hiero-ledger/hiero-sdk-python/blob/main/docs/sdk_developers/rebasing.md
Open a PR and link this issue	https://github.com/hiero-ledger/hiero-sdk-python/blob/main/docs/sdk_developers/training/workflow/11_submit_pull_request.md
Resolve merge conflicts	https://github.com/hiero-ledger/hiero-sdk-python/blob/main/docs/sdk_developers/merge_conflicts.md
Testing	https://github.com/hiero-ledger/hiero-sdk-python/blob/main/docs/sdk_developers/testing.md

📚 Resources & Support

🆘 Stuck?

Comment on this issue and describe what you have tried. A maintainer will respond.

[github-actions]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Create a single JavaScript module (label-constants.js) as the centralized source of truth for the "Good First Issue" label, including the canonical value, alternate forms for cross-repo searches, and case-insensitive matching helpers
• Migrate all JavaScript scripts to import from this shared module, replacing hardcoded constants and inline string comparisons
• For shell scripts, pass the label value via workflow environment variables (following existing patterns), allowing the shell script to read from env with a fallback default
• Fix the discovered bug where bot-intermediate-assignment.js ignores the GFI_LABEL environment variable that its workflow explicitly sets

Design Choices

Design Choice 1: How should the centralized configuration be structured for cross-language consumption (JavaScript scripts vs shell scripts)?

Options Considered:

1. Single JavaScript module as source of truth; shell scripts receive label via workflow environment variables
2. Duplicate configuration in both JavaScript and shell config files
3. Use workflow-level environment variables exclusively for all scripts (no JS module)

Chosen Option: 1

Rationale: A JavaScript module provides the canonical definition and helper utilities; workflows pass the label to shell scripts via environment variables, following the existing pattern in bot-intermediate-assignment.yml.

Design Choice 2: Should alternate label forms (e.g., "skill: good first issue") be included in the centralized configuration?

Options Considered:

1. Include alternate forms as an exported array for scripts that need fallback search capability
2. Keep only the canonical label; let individual scripts handle alternates if needed

Chosen Option: 1

Rationale: Export an array of alternate forms alongside the canonical label, allowing scripts to opt-in to fallback matching where appropriate (e.g., cross-repo searches). This centralizes all GFI label knowledge without forcing all scripts to use alternates.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Create Centralized Label Constants Module

Establish a single source of truth for Good First Issue label handling that can be consumed by all JavaScript scripts and referenced by workflows for shell script integration.

Create Shared Label Constants Module

Create a new JavaScript module that exports the canonical GFI label value, alternate label forms, and helper functions for consistent label matching across all scripts.

• Create new file .github/scripts/label-constants.js as the centralized configuration module
• Export GOOD_FIRST_ISSUE_LABEL constant with value 'Good First Issue' (matching canonical definition in issue template)
• Export GFI_ALTERNATE_LABELS array containing alternate forms: ['skill: good first issue'] for cross-repo search scenarios
• Export isGoodFirstIssueLabel(labelName) helper function that performs case-insensitive comparison against the canonical label
• Export matchesAnyGfiLabel(labelName) helper function that checks against canonical and alternate forms (case-insensitive)
• Include JSDoc comments explaining the module's purpose and when to use each export

🤖 Prompt for AI agents

Create a new file `.github/scripts/label-constants.js` as a centralized
configuration module for all Good First Issue label handling. The goal is to
establish a single source of truth that all JavaScript scripts can import.

- Export a `GOOD_FIRST_ISSUE_LABEL` constant with the value `'Good First Issue'`
(title-cased, matching the canonical definition in
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`)
- Export a `GFI_ALTERNATE_LABELS` array containing alternate label forms:
`['skill: good first issue']`, intended for cross-repo search scenarios
- Export an `isGoodFirstIssueLabel(labelName)` helper function that performs a
case-insensitive comparison of the given label name against the canonical label
- Export a `matchesAnyGfiLabel(labelName)` helper function that checks the given
label name case-insensitively against both the canonical label and all entries
in `GFI_ALTERNATE_LABELS`
- Add JSDoc comments to each export explaining its purpose and when it should be
used
- Add a header comment in the file explaining it is the single source of truth
for GFI label handling, and noting that the canonical label matches
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`

Phase 2: Migrate Scripts to Use Centralized Configuration

Update all JavaScript scripts that reference the GFI label to import from the shared module, and configure shell scripts to receive the label via workflow environment variables.

Task 1: Update bot-gfi-assign-on-comment.js

Migrate from local constant to shared module import for GFI label handling.

• Replace const GOOD_FIRST_ISSUE_LABEL = 'Good First Issue'; (line 9) with import from ./label-constants.js
• Update issueIsGoodFirstIssue() function to use the imported isGoodFirstIssueLabel() helper instead of inline toLowerCase comparison
• Preserve existing case-insensitive matching behavior

Task 2: Update bot-beginner-assign-on-comment.js

Migrate from local constant to shared module import.

• Replace const GFI_LABEL = 'Good First Issue'; with import of GOOD_FIRST_ISSUE_LABEL from ./label-constants.js
• Update all references from GFI_LABEL to the imported constant name
• Preserve existing behavior

Task 3: Update bot-next-issue-recommendation.js

Migrate label detection and search queries to use shared module.

• Import GOOD_FIRST_ISSUE_LABEL, GFI_ALTERNATE_LABELS, and isGoodFirstIssueLabel from ./label-constants.js
• Update the labelSet.has('good first issue') check (line 59) to use the imported helper function
• Update the searchIssues() call (line 88) to use the imported constant instead of hardcoded 'good first issue'
• Update the cross-repo search URL construction (lines 163-179) to use GFI_ALTERNATE_LABELS for building the OR clause
• Preserve existing fallback search behavior

Task 4: Update cron-admin-update-spam-list.js

Update the rehabilitated users search query to use centralized label.

• Import GOOD_FIRST_ISSUE_LABEL from ./label-constants.js
• Update the search query at line 140 to use template literal with imported constant: `label:"${GOOD_FIRST_ISSUE_LABEL}"`
• Preserve existing rehabilitated user detection behavior

Task 5: Update bot-assignment-check.sh and Workflow

Configure shell script to receive GFI label via environment variable from its calling workflow.

• In .github/workflows/bot-assignment-check.yml (or the workflow that invokes this script), add GFI_LABEL: "Good First Issue" to the environment variables passed to the script
• In .github/scripts/bot-assignment-check.sh, add a variable declaration at the top: GFI_LABEL="${GFI_LABEL:-Good First Issue}" to read from env with fallback
• Update the issue_has_gfi() function (lines 39-43) to use the $GFI_LABEL variable in the jq query instead of hardcoded string
• Update user messages that reference the label to use the variable
• Preserve existing exact-match behavior for GitHub API queries

🤖 Prompt for AI agents

Migrate all scripts that reference the GFI label to use the centralized
`label-constants.js` module. The goal is to eliminate hardcoded label strings
and inconsistent matching logic across all scripts.

**bot-gfi-assign-on-comment.js:**
- Remove the local `const GOOD_FIRST_ISSUE_LABEL = 'Good First Issue';`
declaration (line 9) and replace it with an import of `GOOD_FIRST_ISSUE_LABEL`
and `isGoodFirstIssueLabel` from `./label-constants.js`
- Update the `issueIsGoodFirstIssue()` function to use the imported
`isGoodFirstIssueLabel()` helper instead of any inline `toLowerCase()`
comparison
- Preserve existing case-insensitive matching behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-beginner-assign-on-comment.js:**
- Remove the local `const GFI_LABEL = 'Good First Issue';` and replace it with
an import of `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Update all references from `GFI_LABEL` to the imported
`GOOD_FIRST_ISSUE_LABEL` constant name
- Preserve existing behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-next-issue-recommendation.js:**
- Import `GOOD_FIRST_ISSUE_LABEL`, `GFI_ALTERNATE_LABELS`, and
`isGoodFirstIssueLabel` from `./label-constants.js`
- Update the `labelSet.has('good first issue')` check (line 59) to use the
imported `isGoodFirstIssueLabel()` helper
- Update the `searchIssues()` call (line 88) to use the imported
`GOOD_FIRST_ISSUE_LABEL` constant instead of the hardcoded `'good first issue'`
string
- Update the cross-repo search URL construction (lines 163-179) to use
`GFI_ALTERNATE_LABELS` for building the OR clause
- Preserve existing fallback search behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**cron-admin-update-spam-list.js:**
- Import `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Update the search query at line 140 to use a template literal with the
imported constant: `` `label:"${GOOD_FIRST_ISSUE_LABEL}"` ``
- Preserve existing rehabilitated user detection behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-assignment-check.sh and its workflow:**
- In `.github/workflows/bot-assignment-check.yml` (or the workflow invoking this
script), add `GFI_LABEL: "Good First Issue"` to the environment variables block
passed to the script
- In `.github/scripts/bot-assignment-check.sh`, add a variable declaration near
the top: `GFI_LABEL="${GFI_LABEL:-Good First Issue}"` to read from the
environment with a fallback default
- Update the `issue_has_gfi()` function (lines 39-43) to use `$GFI_LABEL` in the
jq query instead of a hardcoded string
- Update any user-facing messages that reference the label to use the
`$GFI_LABEL` variable
- Preserve existing exact-match behavior for GitHub API queries

Phase 3: Fix Discovered Bug and Validate Configuration

Address the bug where bot-intermediate-assignment.js ignores the GFI_LABEL environment variable set by its workflow, and ensure all changes maintain existing behavior.

Task 1: Fix bot-intermediate-assignment.js GFI_LABEL Consumption

The workflow sets GFI_LABEL: Good First Issue but the script reads BEGINNER_LABEL instead, causing a logic mismatch.

• Import GOOD_FIRST_ISSUE_LABEL from ./label-constants.js in .github/scripts/bot-intermediate-assignment.js
• Update countCompletedBeginnerIssues() function (lines 76-82) to support checking for GFI-labeled issues in addition to or instead of beginner-labeled issues
• Evaluate whether the function should check for completed GFI issues (matching the workflow's stated intent via GFI_LABEL env var) or keep the existing beginner label check — preserve current effective behavior
• Add code comment documenting the relationship between BEGINNER_LABEL and GFI_LABEL for future maintainers
• Remove the unused GFI_LABEL env var from .github/workflows/bot-intermediate-assignment.yml if it remains unconsumed, OR wire it to be consumed properly

Task 2: Update bot-intermediate-assignment.yml Workflow Environment

Ensure the workflow correctly passes label configuration to the script.

• Review the env: block (around line 40) that sets GFI_LABEL: Good First Issue
• Either remove the unused GFI_LABEL variable if the script will import from the shared module directly, or ensure the script reads process.env.GFI_LABEL if env var approach is preferred for this workflow
• Ensure BEGINNER_LABEL is explicitly set if needed: BEGINNER_LABEL: beginner
• Document the relationship between these labels in a code comment

Task 3: Add Inline Documentation

Add comments to the shared module and key integration points explaining the centralization rationale.

• Add header comment in label-constants.js explaining this is the single source of truth for GFI label handling
• Add comment noting the canonical label definition matches .github/ISSUE_TEMPLATE/01-good-first-issue.yml
• In each migrated script, add a brief comment at the import statement referencing where to update if label changes

🤖 Prompt for AI agents

Fix the bug in `bot-intermediate-assignment.js` where the workflow-provided
`GFI_LABEL` environment variable is ignored, and clean up the workflow
configuration. The goal is to resolve the logic mismatch and ensure all
configuration is accurate and documented.

**bot-intermediate-assignment.js:**
- Import `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Inspect the `countCompletedBeginnerIssues()` function (lines 76-82): it
currently reads `BEGINNER_LABEL` while the workflow sets `GFI_LABEL: Good First
Issue`
- Evaluate whether the function should check for completed GFI-labeled issues
(matching the workflow's stated intent) or retain the existing beginner label
check — preserve the current effective behavior
- Add a code comment documenting the relationship between `BEGINNER_LABEL` and
`GFI_LABEL` for future maintainers
- Either properly wire `GFI_LABEL` to be consumed via `process.env.GFI_LABEL` or
import the shared constant directly, depending on which aligns with the intended
behavior

**bot-intermediate-assignment.yml workflow:**
- Review the `env:` block (around line 40) that sets `GFI_LABEL: Good First
Issue`
- Remove the `GFI_LABEL` env var if the script will import from the shared
module and no longer reads it from the environment; OR ensure the script
properly reads `process.env.GFI_LABEL` if the env var approach is retained
- Ensure `BEGINNER_LABEL` is explicitly set if still needed (e.g.,
`BEGINNER_LABEL: beginner`)
- Add a code comment in the workflow documenting the relationship between these
labels

**Inline Documentation (all files):**
- Confirm the header comment in `label-constants.js` clearly states it is the
single source of truth and references
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`
- Confirm each migrated script has a brief comment at its import statement
indicating where to update if the label name ever changes

Research

The .github/scripts/ directory contains 30 standalone automation scripts with no shared configuration or constants file. Six scripts and two active workflows reference the "Good First Issue" label with varying approaches: some use exact string matching ("Good First Issue"), others use case-insensitive comparison via toLowerCase(), and one workflow sets a GFI_LABEL environment variable that is never consumed by its target script. The canonical label definition exists in .github/ISSUE_TEMPLATE/01-good-first-issue.yml as "Good First Issue" (title-cased).

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Create a new file `.github/scripts/label-constants.js` as a centralized
configuration module for all Good First Issue label handling. The goal is to
establish a single source of truth that all JavaScript scripts can import.

- Export a `GOOD_FIRST_ISSUE_LABEL` constant with the value `'Good First Issue'`
(title-cased, matching the canonical definition in
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`)
- Export a `GFI_ALTERNATE_LABELS` array containing alternate label forms:
`['skill: good first issue']`, intended for cross-repo search scenarios
- Export an `isGoodFirstIssueLabel(labelName)` helper function that performs a
case-insensitive comparison of the given label name against the canonical label
- Export a `matchesAnyGfiLabel(labelName)` helper function that checks the given
label name case-insensitively against both the canonical label and all entries
in `GFI_ALTERNATE_LABELS`
- Add JSDoc comments to each export explaining its purpose and when it should be
used
- Add a header comment in the file explaining it is the single source of truth
for GFI label handling, and noting that the canonical label matches
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`
===============================================================================

Task: 2

Migrate all scripts that reference the GFI label to use the centralized
`label-constants.js` module. The goal is to eliminate hardcoded label strings
and inconsistent matching logic across all scripts.

**bot-gfi-assign-on-comment.js:**
- Remove the local `const GOOD_FIRST_ISSUE_LABEL = 'Good First Issue';`
declaration (line 9) and replace it with an import of `GOOD_FIRST_ISSUE_LABEL`
and `isGoodFirstIssueLabel` from `./label-constants.js`
- Update the `issueIsGoodFirstIssue()` function to use the imported
`isGoodFirstIssueLabel()` helper instead of any inline `toLowerCase()`
comparison
- Preserve existing case-insensitive matching behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-beginner-assign-on-comment.js:**
- Remove the local `const GFI_LABEL = 'Good First Issue';` and replace it with
an import of `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Update all references from `GFI_LABEL` to the imported
`GOOD_FIRST_ISSUE_LABEL` constant name
- Preserve existing behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-next-issue-recommendation.js:**
- Import `GOOD_FIRST_ISSUE_LABEL`, `GFI_ALTERNATE_LABELS`, and
`isGoodFirstIssueLabel` from `./label-constants.js`
- Update the `labelSet.has('good first issue')` check (line 59) to use the
imported `isGoodFirstIssueLabel()` helper
- Update the `searchIssues()` call (line 88) to use the imported
`GOOD_FIRST_ISSUE_LABEL` constant instead of the hardcoded `'good first issue'`
string
- Update the cross-repo search URL construction (lines 163-179) to use
`GFI_ALTERNATE_LABELS` for building the OR clause
- Preserve existing fallback search behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**cron-admin-update-spam-list.js:**
- Import `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Update the search query at line 140 to use a template literal with the
imported constant: `` `label:"${GOOD_FIRST_ISSUE_LABEL}"` ``
- Preserve existing rehabilitated user detection behavior
- Add a brief comment at the import statement referencing where to update if the
label changes

**bot-assignment-check.sh and its workflow:**
- In `.github/workflows/bot-assignment-check.yml` (or the workflow invoking this
script), add `GFI_LABEL: "Good First Issue"` to the environment variables block
passed to the script
- In `.github/scripts/bot-assignment-check.sh`, add a variable declaration near
the top: `GFI_LABEL="${GFI_LABEL:-Good First Issue}"` to read from the
environment with a fallback default
- Update the `issue_has_gfi()` function (lines 39-43) to use `$GFI_LABEL` in the
jq query instead of a hardcoded string
- Update any user-facing messages that reference the label to use the
`$GFI_LABEL` variable
- Preserve existing exact-match behavior for GitHub API queries
===============================================================================

Task: 3

Fix the bug in `bot-intermediate-assignment.js` where the workflow-provided
`GFI_LABEL` environment variable is ignored, and clean up the workflow
configuration. The goal is to resolve the logic mismatch and ensure all
configuration is accurate and documented.

**bot-intermediate-assignment.js:**
- Import `GOOD_FIRST_ISSUE_LABEL` from `./label-constants.js`
- Inspect the `countCompletedBeginnerIssues()` function (lines 76-82): it
currently reads `BEGINNER_LABEL` while the workflow sets `GFI_LABEL: Good First
Issue`
- Evaluate whether the function should check for completed GFI-labeled issues
(matching the workflow's stated intent) or retain the existing beginner label
check — preserve the current effective behavior
- Add a code comment documenting the relationship between `BEGINNER_LABEL` and
`GFI_LABEL` for future maintainers
- Either properly wire `GFI_LABEL` to be consumed via `process.env.GFI_LABEL` or
import the shared constant directly, depending on which aligns with the intended
behavior

**bot-intermediate-assignment.yml workflow:**
- Review the `env:` block (around line 40) that sets `GFI_LABEL: Good First
Issue`
- Remove the `GFI_LABEL` env var if the script will import from the shared
module and no longer reads it from the environment; OR ensure the script
properly reads `process.env.GFI_LABEL` if the env var approach is retained
- Ensure `BEGINNER_LABEL` is explicitly set if still needed (e.g.,
`BEGINNER_LABEL: beginner`)
- Add a code comment in the workflow documenting the relationship between these
labels

**Inline Documentation (all files):**
- Confirm the header comment in `label-constants.js` clearly states it is the
single source of truth and references
`.github/ISSUE_TEMPLATE/01-good-first-issue.yml`
- Confirm each migrated script has a brief comment at its import statement
indicating where to update if the label name ever changes

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[bhuvan-somisetty]

/assign

[NssGourav]

I reviewed the issue scope and the files listed in the description. I noticed the current Good First Issue handling is already split across a few patterns: for example, bot-gfi-assign-on-comment.js hardcodes Good First Issue,
bot-next-issue-recommendation.js checks good first issue in lowercase and also uses fallback search forms,
while bot-assignment-check.sh does an exact match on Good First Issue.

My understanding is that this issue is a focused automation reliability refactor: centralize that label handling across the relevant .github scripts/workflows, preserve current behavior, and validate the affected flows with targeted testing and fork-based evidence.

I’d like to work on this issue if it’s available.

[tannaya7]

/assign

[ManmathX]

/assign

[vidhhya1]

/assign

[cheese-cakee]

hello @manishdait and @exploreriii can you review this issue and check if its all good before its assigned ?

[exploreriii]

I think this is a good issue, but is also a sensitive one, and there may be a couple rebases on the way. Intermediate sounds a good level for it