Prevent autoChat if people are talking with themselves

[meness]

The bot shouldn't involve in a conversion if people are talking to themselves if autoChat is enabled. I asked CodeRabbit support team, they've done it somehow :D

[meness]

To determine if people in GitHub comments are talking to themselves (and thus decide whether to skip running the chatbot feature), you would need to analyze the comment’s context. The key here is to identify comments that are directed to the author of the comment itself, rather than to another user or a bot.

Here’s an approach you can take:

1. Detecting Self-Directed Comments

You can analyze the comment body to check if the author is mentioning themselves. This can be done by looking for references to their own GitHub username or using more sophisticated Natural Language Processing (NLP) techniques. For simplicity, let’s start with a basic check for mentions of the user’s own GitHub username.

2. Steps to Implement

   1. Check for Mentions of the Comment Author: When a comment is posted, check if the username of the person posting the comment (the author) is mentioned within the comment body.
      • GitHub mentions are usually in the format @username. You can check if the body of the comment contains @<author's username>.
      • If the comment mentions their own username, it’s likely they are talking to themselves.
   2. Use Regular Expressions: A simple regular expression can match @ in the comment.
   3. Skipping the Chatbot Logic: If the condition is met (i.e., the comment author is talking to themselves), you can skip the chatbot processing.

3. Code Example

Here’s how you might implement this in your Dr. GitHub codebase:

// Assuming comment is an object containing the comment body and author information
const isTalkingToSelf = (comment: { body: string; author: string }): boolean => {
const authorMentionRegex = new RegExp(@${comment.author}\\b, 'i');
return authorMentionRegex.test(comment.body);
};

// In your comment processing function
const handleComment = (comment: { body: string; author: string }): void => {
// Check if the comment is directed to the author (self-talk)
if (isTalkingToSelf(comment)) {
console.log('Skipping chatbot: User is talking to themselves');
return;
}

// Run chatbot logic if not talking to themselves
runChatbotFeature(comment);
};

// Example usage
const comment = { body: 'Hey @myusername, I need help with this!', author: 'myusername' };
handleComment(comment);

4. Improvement for Real-World Scenarios

   • Case-Insensitive Matching: The regex above uses the i flag to perform a case-insensitive match, ensuring that @Username and @username are treated the same.
   • Contextual Analysis: If you want more sophistication (e.g., identifying if the comment is really a conversation with themselves or just a mention), you could use an NLP library like spaCy or a pre-trained model to analyze the comment’s intent.
   • Multiple Mentions: Consider scenarios where the comment author mentions themselves but the conversation involves others as well. You can adjust the logic to be more nuanced based on these patterns.

5. Potential Enhancements

   • Exclusion of Comments with Only Self-Mention: If the comment only contains a self-mention and no other context (i.e., a simple comment like @username), you might want to skip the bot feature.
   • User Settings: Allow users to toggle whether or not they want the chatbot to be triggered in self-referencing comments.
   • Conversation Thread Analysis: If a user is commenting in a thread with multiple messages, consider analyzing the context of the whole thread instead of individual comments.

6. Considerations

   • Edge Cases: Users might still address themselves indirectly or in a more nuanced way (e.g., “I need to fix this issue myself”). So, keep in mind that relying on just mentions might not cover all cases, and further contextual analysis could be necessary.
   • Performance: Make sure the logic is optimized so that it doesn’t impact performance when processing large amounts of comments.

This should give you a solid foundation for detecting self-directed comments in GitHub discussions and adjusting your bot behavior accordingly!

[meness]

moved to notion