Implement GitHub bot grammar checker functionality

- Add GrammarCheckTrigger that uses LanguageTool API for grammar and spelling checks
- Integrate trigger into main bot program alongside existing triggers
- Create comprehensive example documentation for usage
- Bot responds to issues with titles containing "grammar", "spell check", "proofread", etc.
- Posts detailed comments with error descriptions, context, and correction suggestions
- Supports real-time grammar checking using free LanguageTool public API

Fixes #81

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: konard

csharp/Platform.Bot/Program.cs

@@ -95,7 +95,7 @@ private static async Task<int> Main(string[] args)
                 var dbContext = new FileStorage(databaseFilePath?.FullName ?? new TemporaryFile().Filename);
                 Console.WriteLine($"Bot has been started. {Environment.NewLine}Press CTRL+C to close");
                 var githubStorage = new GitHubStorage(githubUserName, githubApiToken, githubApplicationName);
-                var issueTracker = new IssueTracker(githubStorage, new HelloWorldTrigger(githubStorage, dbContext, fileSetName), new OrganizationLastMonthActivityTrigger(githubStorage), new LastCommitActivityTrigger(githubStorage), new AdminAuthorIssueTriggerDecorator(new ProtectDefaultBranchTrigger(githubStorage), githubStorage), new AdminAuthorIssueTriggerDecorator(new ChangeOrganizationRepositoriesDefaultBranchTrigger(githubStorage, dbContext), githubStorage), new AdminAuthorIssueTriggerDecorator(new ChangeOrganizationPullRequestsBaseBranchTrigger(githubStorage, dbContext), githubStorage));
+                var issueTracker = new IssueTracker(githubStorage, new HelloWorldTrigger(githubStorage, dbContext, fileSetName), new GrammarCheckTrigger(githubStorage), new OrganizationLastMonthActivityTrigger(githubStorage), new LastCommitActivityTrigger(githubStorage), new AdminAuthorIssueTriggerDecorator(new ProtectDefaultBranchTrigger(githubStorage), githubStorage), new AdminAuthorIssueTriggerDecorator(new ChangeOrganizationRepositoriesDefaultBranchTrigger(githubStorage, dbContext), githubStorage), new AdminAuthorIssueTriggerDecorator(new ChangeOrganizationPullRequestsBaseBranchTrigger(githubStorage, dbContext), githubStorage));
                 var pullRequenstTracker = new PullRequestTracker(githubStorage, new MergeDependabotBumpsTrigger(githubStorage));
                 var timestampTracker = new DateTimeTracker(githubStorage, new CreateAndSaveOrganizationRepositoriesMigrationTrigger(githubStorage, dbContext, Path.Combine(Directory.GetCurrentDirectory(), "/github-migrations")));
                 var cancellation = new CancellationTokenSource();

csharp/Platform.Bot/Triggers/GrammarCheckTrigger.cs

@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Interfaces;
+using Octokit;
+using Storage.Remote.GitHub;
+
+namespace Platform.Bot.Triggers
+{
+    using TContext = Issue;
+    
+    /// <summary>
+    /// <para>
+    /// Represents a grammar and spelling check trigger using LanguageTool API.
+    /// </para>
+    /// <para></para>
+    /// </summary>
+    /// <seealso cref="ITrigger{TContext}"/>
+    internal class GrammarCheckTrigger : ITrigger<TContext>
+    {
+        private readonly GitHubStorage _storage;
+        private readonly HttpClient _httpClient;
+        private const string LanguageToolApiUrl = "https://api.languagetool.org/v2/check";
+
+        /// <summary>
+        /// <para>
+        /// Initializes a new <see cref="GrammarCheckTrigger"/> instance.
+        /// </para>
+        /// <para></para>
+        /// </summary>
+        /// <param name="storage">
+        /// <para>A GitHub storage instance.</para>
+        /// <para></para>
+        /// </param>
+        public GrammarCheckTrigger(GitHubStorage storage)
+        {
+            _storage = storage;
+            _httpClient = new HttpClient();
+        }
+
+        /// <summary>
+        /// <para>
+        /// Determines whether this instance should be triggered based on the issue context.
+        /// </para>
+        /// <para></para>
+        /// </summary>
+        /// <param name="context">
+        /// <para>The issue context.</para>
+        /// <para></para>
+        /// </param>
+        /// <returns>
+        /// <para>True if the issue title contains "grammar check" or "spell check", otherwise false.</para>
+        /// <para></para>
+        /// </returns>
+        public async Task<bool> Condition(TContext context)
+        {
+            var title = context.Title.ToLowerInvariant();
+            return title.Contains("grammar check") || 
+                   title.Contains("spell check") || 
+                   title.Contains("proofread") ||
+                   title.Contains("grammar") ||
+                   title.Contains("spelling");
+        }
+
+        /// <summary>
+        /// <para>
+        /// Performs grammar and spelling check on the issue description and posts corrections as a comment.
+        /// </para>
+        /// <para></para>
+        /// </summary>
+        /// <param name="context">
+        /// <para>The issue context.</para>
+        /// <para></para>
+        /// </param>
+        public async Task Action(TContext context)
+        {
+            try
+            {
+                // Get the text to check (issue description)
+                var textToCheck = context.Body ?? "";
+                
+                if (string.IsNullOrWhiteSpace(textToCheck))
+                {
+                    await _storage.CreateIssueComment(context.Repository.Id, context.Number, 
+                        "⚠️ No text found to check for grammar or spelling errors.");
+                    return;
+                }
+
+                // Call LanguageTool API to check grammar and spelling
+                var suggestions = await CheckGrammarAndSpelling(textToCheck);
+                
+                if (suggestions.Count == 0)
+                {
+                    await _storage.CreateIssueComment(context.Repository.Id, context.Number, 
+                        "✅ No grammar or spelling issues found in the issue description!");
+                    return;
+                }
+
+                // Format the response with suggestions
+                var responseBuilder = new StringBuilder();
+                responseBuilder.AppendLine("## Grammar and Spelling Check Results");
+                responseBuilder.AppendLine();
+                responseBuilder.AppendLine($"Found **{suggestions.Count}** potential issue(s):");
+                responseBuilder.AppendLine();
+
+                for (int i = 0; i < suggestions.Count; i++)
+                {
+                    var suggestion = suggestions[i];
+                    responseBuilder.AppendLine($"**{i + 1}.** {suggestion.Message}");
+                    
+                    if (!string.IsNullOrEmpty(suggestion.Context))
+                    {
+                        responseBuilder.AppendLine($"   - Context: \"{suggestion.Context}\"");
+                    }
+                    
+                    if (suggestion.Replacements?.Count > 0)
+                    {
+                        responseBuilder.AppendLine($"   - Suggested correction(s): {string.Join(", ", suggestion.Replacements)}");
+                    }
+                    
+                    responseBuilder.AppendLine();
+                }
+
+                responseBuilder.AppendLine("---");
+                responseBuilder.AppendLine("*Grammar checking powered by LanguageTool API*");
+
+                // Post the comment
+                await _storage.CreateIssueComment(context.Repository.Id, context.Number, responseBuilder.ToString());
+            }
+            catch (Exception ex)
+            {
+                await _storage.CreateIssueComment(context.Repository.Id, context.Number, 
+                    $"❌ Error occurred during grammar check: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// <para>
+        /// Calls the LanguageTool API to check grammar and spelling.
+        /// </para>
+        /// <para></para>
+        /// </summary>
+        /// <param name="text">
+        /// <para>The text to check.</para>
+        /// <para></para>
+        /// </param>
+        /// <returns>
+        /// <para>A list of grammar and spelling suggestions.</para>
+        /// <para></para>
+        /// </returns>
+        private async Task<List<GrammarSuggestion>> CheckGrammarAndSpelling(string text)
+        {
+            try
+            {
+                var formData = new FormUrlEncodedContent(new[]
+                {
+                    new KeyValuePair<string, string>("text", text),
+                    new KeyValuePair<string, string>("language", "en-US")
+                });
+
+                var response = await _httpClient.PostAsync(LanguageToolApiUrl, formData);
+                response.EnsureSuccessStatusCode();
+
+                var jsonResponse = await response.Content.ReadAsStringAsync();
+                var apiResponse = JsonSerializer.Deserialize<LanguageToolResponse>(jsonResponse);
+
+                var suggestions = new List<GrammarSuggestion>();
+                
+                if (apiResponse?.matches != null)
+                {
+                    foreach (var match in apiResponse.matches)
+                    {
+                        var suggestion = new GrammarSuggestion
+                        {
+                            Message = match.message ?? "Grammar/spelling issue detected",
+                            Context = GetContextFromMatch(text, match),
+                            Replacements = match.replacements?.ConvertAll(r => r.value) ?? new List<string>()
+                        };
+                        
+                        suggestions.Add(suggestion);
+                    }
+                }
+
+                return suggestions;
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Failed to check grammar with LanguageTool API: {ex.Message}", ex);
+            }
+        }
+
+        /// <summary>
+        /// <para>
+        /// Extracts context around a grammar/spelling error.
+        /// </para>
+        /// <para></para>
+        /// </summary>
+        /// <param name="text">
+        /// <para>The full text.</para>
+        /// <para></para>
+        /// </param>
+        /// <param name="match">
+        /// <para>The match information from LanguageTool.</para>
+        /// <para></para>
+        /// </param>
+        /// <returns>
+        /// <para>A context string showing the error in context.</para>
+        /// <para></para>
+        /// </returns>
+        private static string GetContextFromMatch(string text, LanguageToolMatch match)
+        {
+            try
+            {
+                var start = Math.Max(0, match.offset - 20);
+                var end = Math.Min(text.Length, match.offset + match.length + 20);
+                var context = text.Substring(start, end - start);
+                
+                // Highlight the error in the context
+                var errorText = text.Substring(match.offset, match.length);
+                context = context.Replace(errorText, $"**{errorText}**");
+                
+                return context;
+            }
+            catch
+            {
+                return "";
+            }
+        }
+    }
+
+    /// <summary>
+    /// <para>
+    /// Represents a grammar or spelling suggestion.
+    /// </para>
+    /// <para></para>
+    /// </summary>
+    internal class GrammarSuggestion
+    {
+        public string Message { get; set; } = "";
+        public string Context { get; set; } = "";
+        public List<string> Replacements { get; set; } = new();
+    }
+
+    /// <summary>
+    /// <para>
+    /// Response model for LanguageTool API.
+    /// </para>
+    /// <para></para>
+    /// </summary>
+    internal class LanguageToolResponse
+    {
+        public List<LanguageToolMatch>? matches { get; set; }
+    }
+
+    /// <summary>
+    /// <para>
+    /// Match model for LanguageTool API response.
+    /// </para>
+    /// <para></para>
+    /// </summary>
+    internal class LanguageToolMatch
+    {
+        public string? message { get; set; }
+        public int offset { get; set; }
+        public int length { get; set; }
+        public List<LanguageToolReplacement>? replacements { get; set; }
+    }
+
+    /// <summary>
+    /// <para>
+    /// Replacement model for LanguageTool API response.
+    /// </para>
+    /// <para></para>
+    /// </summary>
+    internal class LanguageToolReplacement
+    {
+        public string value { get; set; } = "";
+    }
+}

examples/GrammarCheckExample.md

@@ -0,0 +1,75 @@
+# Grammar Check Bot Example
+
+This document demonstrates how to use the GitHub bot's grammar checking functionality.
+
+## Overview
+
+The bot includes a `GrammarCheckTrigger` that automatically checks issues for grammar and spelling errors using the LanguageTool API. When triggered, the bot will:
+
+1. Analyze the issue description for grammar and spelling mistakes
+2. Post a comment with suggested corrections
+3. Provide context and replacement suggestions for each error found
+
+## How to Trigger
+
+The grammar checker will activate when you create an issue with a title containing any of these keywords:
+- "grammar check"
+- "spell check" 
+- "proofread"
+- "grammar"
+- "spelling"
+
+## Example Usage
+
+### Issue Title Examples
+- "Grammar check please"
+- "Can you proofread this text?"
+- "Check spelling errors in this document"
+- "Grammar and spelling review needed"
+
+### Expected Bot Response
+
+If the issue description contains text like:
+```
+This is a test with grammer mistakes and speling erors.
+```
+
+The bot will respond with:
+```
+## Grammar and Spelling Check Results
+
+Found **3** potential issue(s):
+
+**1.** Possible spelling mistake found.
+   - Context: "This is a test with **grammer** mistakes and speling erors."
+   - Suggested correction(s): grammar, grimmer, rammer, crammer, g rammer
+
+**2.** Possible spelling mistake found.
+   - Context: "...his is a test with grammer mistakes and **speling** erors."
+   - Suggested correction(s): spelling, spewing, spieling
+
+**3.** Possible spelling mistake found.
+   - Context: "... test with grammer mistakes and speling **erors**."
+   - Suggested correction(s): errors, Eros, errs
+
+---
+*Grammar checking powered by LanguageTool API*
+```
+
+## Technical Details
+
+- **API**: Uses LanguageTool public API (https://api.languagetool.org/v2/check)
+- **Language**: Defaults to English (US)
+- **Trigger Logic**: Located in `csharp/Platform.Bot/Triggers/GrammarCheckTrigger.cs`
+- **Integration**: Added to the main issue tracker in `Program.cs`
+
+## Configuration
+
+The trigger is automatically enabled when the bot starts. No additional configuration is required.
+
+## Limitations
+
+- Uses the free LanguageTool API (limited requests per day)
+- Only checks the issue description, not comments
+- Currently supports English language only
+- Requires internet connectivity to reach the LanguageTool API