contributor-issue-comment.js

// See docs/community-automations.md

const {
  LE_BOT_USERNAME,
  KEYWORDS_DETECT_ASSIGNMENT_REQUEST,
  ISSUE_LABEL_HELP_WANTED,
  BOT_MESSAGE_ISSUE_NOT_OPEN,
  BOT_MESSAGE_ALREADY_ASSIGNED,
  COMMUNITY_REPOS,
} = require('./constants');
const {
  isCloseContributor,
  sendBotMessage,
  escapeIssueTitleForSlackMessage,
  hasRecentBotComment,
  hasLabel,
  getIssues,
  getPullRequests,
} = require('./utils');

// Format information about author's assigned open issues
// as '(Issues #1 #2 | PRs #3)' and PRs for Slack message
function formatAuthorActivity(issues, pullRequests) {
  const parts = [];

  if (issues.length > 0) {
    const issueLinks = issues.map(issue => `<${issue.html_url}|#${issue.number}>`).join(' ');
    parts.push(`Issues ${issueLinks}`);
  } else {
    parts.push(`Issues none`);
  }

  if (pullRequests.length > 0) {
    const prLinks = pullRequests.map(pr => `<${pr.html_url}|#${pr.number}>`).join(' ');
    parts.push(`PRs ${prLinks}`);
  } else {
    parts.push(`PRs none`);
  }

  return `(${parts.join(' | ')})`;
}

function shouldSendBotReply(
  issueCreator,
  commentAuthor,
  commentAuthorIsCloseContributor,
  isHelpWanted,
  isAssignmentRequest,
  isIssueAssignedToSomeoneElse,
) {
  if (commentAuthorIsCloseContributor) {
    return [false, null];
  }

  if (issueCreator === commentAuthor) {
    return [false, null];
  }

  if (isHelpWanted && isIssueAssignedToSomeoneElse && isAssignmentRequest) {
    return [true, BOT_MESSAGE_ALREADY_ASSIGNED];
  }

  if (!isHelpWanted && isAssignmentRequest) {
    return [true, BOT_MESSAGE_ISSUE_NOT_OPEN];
  }

  return [false, null];
}

function shouldContactSupport(
  commentAuthorIsCloseContributor,
  isHelpWanted,
  isIssueAssignedToSomeoneElse,
) {
  if (commentAuthorIsCloseContributor) {
    return true;
  }

  if (!isHelpWanted) {
    return false;
  }

  if (isHelpWanted && isIssueAssignedToSomeoneElse) {
    return false;
  }

  return true;
}

module.exports = async ({ github, context, core }) => {
  try {
    const issueNumber = context.payload.issue.number;
    const issueUrl = context.payload.issue.html_url;
    const issueTitle = escapeIssueTitleForSlackMessage(context.payload.issue.title);
    const issueCreator = context.payload.issue.user.login;
    const issueAssignees = context.payload.issue.assignees?.map(assignee => assignee.login) || [];
    const commentId = context.payload.comment.id;
    const commentAuthor = context.payload.comment.user.login;
    const commentBody = context.payload.comment.body;
    const repo = context.repo.repo;
    const owner = context.repo.owner;
    const keywordRegexes = KEYWORDS_DETECT_ASSIGNMENT_REQUEST.map(k => k.trim().toLowerCase())
      .filter(Boolean)
      .map(keyword => new RegExp(`\\b${keyword}\\b`, 'i'));
    const isAssignmentRequest = keywordRegexes.find(regex => regex.test(commentBody));
    const isIssueAssignedToSomeoneElse =
      issueAssignees && issueAssignees.length > 0 && !issueAssignees.includes(commentAuthor);
    const isHelpWanted = await hasLabel(
      ISSUE_LABEL_HELP_WANTED,
      owner,
      repo,
      issueNumber,
      github,
      core,
    );
    const commentAuthorIsCloseContributor = await isCloseContributor(commentAuthor, {
      github,
      context,
      core,
    });

    const [shouldPostBot, botMessage] = shouldSendBotReply(
      issueCreator,
      commentAuthor,
      commentAuthorIsCloseContributor,
      isHelpWanted,
      isAssignmentRequest,
      isIssueAssignedToSomeoneElse,
    );
    if (shouldPostBot) {
      // post bot reply only when there are no same bot comments
      // in the past hour to prevent overwhelming issue comment section
      const skipBot = await hasRecentBotComment(issueNumber, LE_BOT_USERNAME, botMessage, 3600000, {
        github,
        context,
        core,
      });
      if (skipBot) {
        const slackMessage = `*[${repo}] Bot response skipped on issue: <${issueUrl}|${issueTitle}> (less than 1 hour since last bot message)*`;
        core.setOutput('support_dev_notifications_bot', slackMessage);
      } else {
        const botMessageUrl = await sendBotMessage(issueNumber, botMessage, {
          github,
          context,
          core,
        });
        if (botMessageUrl) {
          const slackMessage = `*[${repo}] <${botMessageUrl}|Bot response sent> on issue: <${issueUrl}|${issueTitle}>*`;
          core.setOutput('support_dev_notifications_bot', slackMessage);
        }
      }
    }

    const contactSupport = shouldContactSupport(
      commentAuthorIsCloseContributor,
      isHelpWanted,
      isIssueAssignedToSomeoneElse,
    );
    let slackMessage = `*[${repo}] <${issueUrl}#issuecomment-${commentId}|New comment> on issue: <${issueUrl}|${issueTitle}> by _${commentAuthor}_*`;

    if (contactSupport) {
      const [assignedOpenIssues, openPRs] = await Promise.all([
        getIssues(commentAuthor, 'open', owner, COMMUNITY_REPOS, github, core),
        getPullRequests(commentAuthor, 'open', owner, COMMUNITY_REPOS, github, core),
      ]);
      const authorActivity = formatAuthorActivity(assignedOpenIssues, openPRs);
      slackMessage += ` _${authorActivity}_`;
      core.setOutput('support_dev_message', slackMessage);
    } else {
      core.setOutput('support_dev_notifications_message', slackMessage);
    }
  } catch (error) {
    core.setFailed(`Action failed with error: ${error.message}`);
  }
};