[Intermediate]: Create /unassign bot

[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

Unassigning from issues is sometimes necessary and also wanted by users, for example, life got busy or the issue was not a good fit.

We can make this easier and simpler for users by listening to an /unassign command

💡 Expected Solution

Add a github action workflow that listens for /unassign, and it then unassigns the user

🧠 Implementation Notes

For open and assigned issues:

• if assignee
• comments /unassign
• unassign the user

safeguards:

• in case the user /assign again and /unassign (could happen, let's say the issue went unassigned for a few days, they had time again, and want to try it).... we can add some kind of count that limits how many times they can do this.
  For now, the simplest approach is probably
• if the user has already requested /unassign
• any subsequent /unassign comment does nothing (its up to the maintainer to do)

bonus 1
We can adjust the reminder workflows...
are you still working on this issue etc?
each of these can have a comment saying: if you no longer want to work on this, just comment /unassign

bonus 2: if a user does want to unassign from an issue, it can also close any linked PRs. This might be tackled better in a new issue.

bonus 3 (but maybe not worth it): in the gfi and beginner auto assign bot guards, we can check.. if they have already previously required /unassign, any new /assign request is skipped.This might be tackled better in a new issue.

Relevant workflows

Relevant scripts:
.github/scripts/bot-gfi-assign-on-comment.js
.github/scripts/bot-beginner-assign-on-comment.js

.github/scripts/bot-issue-reminder-no-pr.sh
.github/scripts/pr_inactivity_reminder.js

✅ 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
• Use DCO and GPG-signed commits

📚 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 #1472
gh issue view 1472 --json title,body,labels,author,createdAt,state

Length of output: 3253

---

🏁 Script executed:

#!/bin/bash
# Read existing bot assignment scripts to understand patterns
echo "=== bot-gfi-assign-on-comment.js ==="
cat .github/scripts/bot-gfi-assign-on-comment.js

echo -e "\n\n=== bot-beginner-assign-on-comment.js ==="
cat .github/scripts/bot-beginner-assign-on-comment.js

echo -e "\n\n=== bot-issue-reminder-no-pr.sh ==="
cat .github/scripts/bot-issue-reminder-no-pr.sh

echo -e "\n\n=== pr_inactivity_reminder.js ==="
cat .github/scripts/pr_inactivity_reminder.js

Length of output: 33653

---

@github-actions[bot], I'll create a plan for implementing the /unassign bot based on issue #1472.

Task: Implement /unassign Bot for Self-Unassignment

Overview:
Create a GitHub Actions bot that allows users to unassign themselves from issues by commenting /unassign. The bot will include safeguards to prevent abuse and will follow patterns established by existing assignment bots.

Implementation Plan:

• Create new JavaScript script for handling /unassign command
• Create or update GitHub Actions workflow to trigger on issue comments
• Track unassign history to limit repeated assign/unassign cycles
• Update reminder workflows to mention /unassign option (bonus)

`

• Use github.rest.issues.removeAssignees() API
• Include comprehensive error handling with try/catch blocks
• Add detailed console logging for debugging
• Handle edge cases (multiple assignees, collaborators, etc.)

File: .github/scripts/bot-unassign-on-comment.js

// .github/scripts/bot-unassign-on-comment.js
//
// Allows assigned users to unassign themselves from issues using /unassign command.
// Includes safeguards to prevent repeated assign/unassign abuse.

const UNASSIGN_HISTORY_MARKER_PREFIX = '<!-- unassign-history:';

/**
 * Returns true if /unassign appears as a standalone command in the comment
 */
function commentRequestsUnassignment(body) {
    const matches =
        typeof body === 'string' &&
        /(^|\s)\/unassign(\s|$)/i.test(body);

    console.log('[unassign-bot] commentRequestsUnassignment:', {
        body,
        matches,
    });

    return matches;
}

/**
 * Check if user has already unassigned from this issue before
 */
async function hasUnassignedBefore(github, owner, repo, issueNumber, username) {
    try {
        const comments = await github.paginate(
            github.rest.issues.listComments,
            {
                owner,
                repo,
                issue_number: issueNumber,
                per_page: 100,
            }
        );

        const marker = `${UNASSIGN_HISTORY_MARKER_PREFIX} @${username}`;
        return comments.some(c => c.body?.includes(marker));
    } catch (error) {
        console.error('[unassign-bot] Error checking unassign history:', error);
        return false; // Fail open - allow unassign if we can't check
    }
}

/**
 * Record that user has unassigned from this issue
 */
async function recordUnassignment(github, owner, repo, issueNumber, username) {
    const marker = `${UNASSIGN_HISTORY_MARKER_PREFIX} @${username} -->`;
    const message = `${marker}
@${username} has unassigned themselves from this issue.`;

    try {
        await github.rest.issues.createComment({
            owner,
            repo,
            issue_number: issueNumber,
            body: message,
        });
        console.log('[unassign-bot] Recorded unassignment for user:', username);
    } catch (error) {
        console.error('[unassign-bot] Failed to record unassignment:', error);
    }
}

module.exports = async ({ github, context }) => {
    try {
        const { issue, comment } = context.payload;
        const { owner, repo } = context.repo;

        console.log('[unassign-bot] Payload snapshot:', {
            issueNumber: issue?.number,
            commenter: comment?.user?.login,
            commenterType: comment?.user?.type,
            commentBody: comment?.body,
        });

        // Basic validation
        if (!issue?.number) {
            console.log('[unassign-bot] Exit: missing issue number');
            return;
        }

        if (issue.pull_request) {
            console.log('[unassign-bot] Exit: this is a pull request, not an issue');
            return;
        }

        if (!comment?.body) {
            console.log('[unassign-bot] Exit: missing comment body');
            return;
        }

        if (!comment?.user?.login) {
            console.log('[unassign-bot] Exit: missing comment user login');
            return;
        }

        if (comment.user.type === 'Bot') {
            console.log('[unassign-bot] Exit: comment authored by bot');
            return;
        }

        // Check for unassign command
        if (!commentRequestsUnassignment(comment.body)) {
            console.log('[unassign-bot] Exit: comment does not request unassignment');
            return;
        }

        console.log('[unassign-bot] Unassignment command detected');

        const requesterUsername = comment.user.login;
        const issueNumber = issue.number;

        // Check if issue is open
        if (issue.state !== 'open') {
            console.log('[unassign-bot] Exit: issue is not open');
            await github.rest.issues.createComment({
                owner,
                repo,
                issue_number: issueNumber,
                body: `@${requesterUsername}, this issue is already closed, so there's nothing to unassign.`,
            });
            return;
        }

        // Check if issue has assignees
        if (!issue.assignees || issue.assignees.length === 0) {
            console.log('[unassign-bot] Exit: issue has no assignees');
            await github.rest.issues.createComment({
                owner,
                repo,
                issue_number: issueNumber,
                body: `@${requesterUsername}, this issue is not currently assigned to anyone.`,
            });
            return;
        }

        // Check if requester is an assignee
        const isAssignee = issue.assignees.some(a => a.login === requesterUsername);
        if (!isAssignee) {
            console.log('[unassign-bot] Exit: requester is not an assignee');
            const assigneeList = issue.assignees.map(a => `@${a.login}`).join(', ');
            await github.rest.issues.createComment({
                owner,
                repo,
                issue_number: issueNumber,
                body: `@${requesterUsername}, you are not assigned to this issue. Current assignees: ${assigneeList}`,
            });
            return;
        }

        // Check unassign history
        const hasUnassignedPreviously = await hasUnassignedBefore(
            github,
            owner,
            repo,
            issueNumber,
            requesterUsername
        );

        if (hasUnassignedPreviously) {
            console.log('[unassign-bot] Exit: user has already unassigned once');
            await github.rest.issues.createComment({
                owner,
                repo,
                issue_number: issueNumber,
                body: `@${requesterUsername}, you have already unassigned from this issue once. To prevent repeated assign/unassign cycles, please contact a maintainer if you need to be unassigned again.`,
            });
            return;
        }

        console.log('[unassign-bot] Unassigning user from issue');

        // Unassign the user
        await github.rest.issues.removeAssignees({
            owner,
            repo,
            issue_number: issueNumber,
            assignees: [requesterUsername],
        });

        console.log('[unassign-bot] Successfully unassigned');

        // Record the unassignment
        await recordUnassignment(github, owner, repo, issueNumber, requesterUsername);

        console.log('[unassign-bot] Unassignment completed successfully');

    } catch (error) {
        console.error('[unassign-bot] Error:', {
            message: error.message,
            status: error.status,
            issueNumber: context.payload.issue?.number,
            commenter: context.payload.comment?.user?.login,
        });
        throw error;
    }
};

-->

Note: Bonus features 2 (closing linked PRs on unassign) and 3 (guarding reassignment after unassign) are intentionally left for follow-up issues as they involve more complex logic and edge cases. Let me know if you'd like me to create separate issues for those enhancements!

---

🏁 Script executed:

#!/bin/bash
# Check if there's an existing workflow that handles issue_comment events
echo "=== Checking for existing issue comment workflows ==="
fd -e yml -e yaml . .github/workflows/ --exec cat {}

Length of output: 52664

---

🏁 Script executed:

#!/bin/bash
# Check for existing documentation files that might need updates
echo "=== Checking for documentation files ==="
fd -e md . --max-depth 2 | head -20

echo -e "\n=== Checking for contributor guides ==="
fd -i contributing . --max-depth 3

Length of output: 202

---

---

🏁 Script executed:

#!/bin/bash
# Read the CONTRIBUTING.md file to understand its structure
echo "=== CONTRIBUTING.md content ==="
cat CONTRIBUTING.md

Length of output: 5495

---

---

@github-actions I've created a comprehensive implementation plan for the /unassign bot feature requested in issue #1472. Another agent will now handle the actual implementation of these changes.

Summary

The plan includes:

1. Core Bot Script (.github/scripts/bot-unassign-on-comment.js): Handles /unassign commands with validation checks and safeguards to prevent abuse
2. GitHub Actions Workflow (.github/workflows/unassign-on-comment.yml): Triggers the bot on issue comments
3. Reminder Updates (Bonus 1): Updates to both bot-issue-reminder-no-pr.sh and pr_inactivity_reminder.js to mention the /unassign option
4. Documentation Updates: Updates to CONTRIBUTING.md and a comprehensive testing checklist
5. Safeguards:
   • Tracks unassign history using hidden comment markers
   • Limits users to one /unassign per issue (prevents assign/unassign cycling)
   • Validates the commenter is actually assigned before unassigning
   • Ignores bot comments and PR comments

The implementation follows existing patterns from the bot-gfi-assign-on-comment.js and bot-beginner-assign-on-comment.js scripts to maintain consistency across the codebase.

Note: Bonus features 2 (closing linked PRs) and 3 (guarding reassignment) are intentionally left for future issues as they involve more complex logic and edge cases that deserve separate focused implementations.

---

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

[undefinedIsMyLife]

I’d like to work on this issue.

[CODEAbhinav-art]

I’d like to work on this issue.
kindly comment "/assign" to get assigned by the bot

[undefinedIsMyLife]

/assign