opengrammar-server 2.0.615350

package/src/rules/categories/gerund-infinitive.ts

@@ -0,0 +1,274 @@
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ════════════════════════════════════════════════════════
+ *  Gerund vs Infinitive Rules — GI Module
+ *  Modal Verb Errors — MV Module
+ * ════════════════════════════════════════════════════════
+ */
+export const gerundInfinitiveRules: Rule[] = [
+
+  // ═══════════════════════════════════════════════
+  // MODAL VERBS: Cannot be followed by "to" + base
+  // ═══════════════════════════════════════════════
+  createRegexRule({
+    id: 'MV_must_to',
+    category: 'grammar',
+    pattern: /\bmust\s+to\s+(\w+)/i,
+    suggestion: (m) => `must ${m[1]}`,
+    reason: 'Modal verbs (must, can, will, may, should) are followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_can_to',
+    category: 'grammar',
+    pattern: /\bcan\s+to\s+(\w+)/i,
+    suggestion: (m) => `can ${m[1]}`,
+    reason: '"Can" is a modal verb and is followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_will_to',
+    category: 'grammar',
+    pattern: /\bwill\s+to\s+(\w+)/i,
+    suggestion: (m) => `will ${m[1]}`,
+    reason: '"Will" is a modal verb and is followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_might_to',
+    category: 'grammar',
+    pattern: /\bmight\s+to\s+(\w+)/i,
+    suggestion: (m) => `might ${m[1]}`,
+    reason: '"Might" is a modal verb and is followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_may_to',
+    category: 'grammar',
+    pattern: /\bmay\s+to\s+(\w+)/i,
+    suggestion: (m) => `may ${m[1]}`,
+    reason: '"May" is a modal verb and is followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_would_to',
+    category: 'grammar',
+    pattern: /\bwould\s+to\s+(\w+)/i,
+    suggestion: (m) => `would ${m[1]}`,
+    reason: '"Would" is followed by the base form without "to".',
+  }),
+  createRegexRule({
+    id: 'MV_could_to',
+    category: 'grammar',
+    pattern: /\bcould\s+to\s+(\w+)/i,
+    suggestion: (m) => `could ${m[1]}`,
+    reason: '"Could" is a modal verb and is followed by the base form without "to".',
+  }),
+
+  // ═══════════════════════════════════════════════
+  // BE + ADJECTIVE (not "be + verb")
+  // ═══════════════════════════════════════════════
+  createRegexRule({
+    id: 'GI_be_agree',
+    category: 'grammar',
+    pattern: /\b(am|is|are|was|were|be|been)\s+agree\b/i,
+    suggestion: (m) => `${m[1]} in agreement`,
+    reason: '"Agree" is a verb, not an adjective. Say "I agree" or "I am in agreement".',
+  }),
+  createRegexRule({
+    id: 'GI_be_depend',
+    category: 'grammar',
+    pattern: /\b(am|is|are|was|were|be|been)\s+depend\b/i,
+    suggestion: (m) => `${m[1]} dependent`,
+    reason: 'Use "dependent on" not "depend on" after the verb "be".',
+  }),
+
+  // ═══════════════════════════════════════════════
+  // VERBS THAT REQUIRE GERUND (not TO + infinitive)
+  // ═══════════════════════════════════════════════
+
+  // avoid
+  createRegexRule({
+    id: 'GI_avoid_to',
+    category: 'grammar',
+    pattern: /\bavoid\s+to\s+(\w+)/i,
+    suggestion: (m) => `avoid ${m[1]}ing`,
+    reason: '"Avoid" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // enjoy
+  createRegexRule({
+    id: 'GI_enjoy_to',
+    category: 'grammar',
+    pattern: /\benjoy\s+to\s+(\w+)/i,
+    suggestion: (m) => `enjoy ${m[1]}ing`,
+    reason: '"Enjoy" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // suggest
+  createRegexRule({
+    id: 'GI_suggest_to',
+    category: 'grammar',
+    pattern: /\bsuggested?\s+to\s+(?!him\b|her\b|them\b|me\b|us\b|you\b|him|her|them|me|us|you)(\w+)/i,
+    suggestion: (m) => `suggest${m[0].match(/suggested/) ? 'ed' : ''} ${m[1]}ing`,
+    reason: '"Suggest" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // consider
+  createRegexRule({
+    id: 'GI_consider_to',
+    category: 'grammar',
+    pattern: /\bconsidered?\s+to\s+(?!be\b|have\b)(\w+)/i,
+    suggestion: (m) => `consider${m[0].match(/considered/) ? 'ed' : ''} ${m[1]}ing`,
+    reason: '"Consider" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // keep
+  createRegexRule({
+    id: 'GI_keep_to',
+    category: 'grammar',
+    pattern: /\bkept\s+to\s+(\w+(?:ing)?)\b(?!\s+(the|a|an|his|her|their|our|my|your)\b)/i,
+    suggestion: (m) => `kept ${m[1].endsWith('ing') ? m[1] : m[1] + 'ing'}`,
+    reason: '"Keep" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // admit
+  createRegexRule({
+    id: 'GI_admit_to_verb',
+    category: 'grammar',
+    pattern: /\badmitted?\s+to\s+(\w+(?:e)?)\b(?!\s+(the|a|an|it|him|her|them|us|me|you)\b)/i,
+    suggestion: (m) => {
+      const verb = m[1];
+      const gerund = verb.endsWith('e') ? verb.slice(0, -1) + 'ing' : verb + 'ing';
+      return `admit${m[0].match(/admitted/) ? 'ted' : ''} to ${gerund}`;
+    },
+    reason: '"Admit to" is followed by a gerund (-ing form).',
+  }),
+
+  // practice
+  createRegexRule({
+    id: 'GI_practice_to',
+    category: 'grammar',
+    pattern: /\bpractice\s+to\s+(\w+)/i,
+    suggestion: (m) => `practice ${m[1]}ing`,
+    reason: '"Practice" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // deny
+  createRegexRule({
+    id: 'GI_deny_to',
+    category: 'grammar',
+    pattern: /\bdenied?\s+to\s+(?!him\b|her\b|them\b|me\b|us\b|you\b)(\w+)/i,
+    suggestion: (m) => `deni${m[0].match(/denied/) ? 'ed' : 'es'} ${m[1]}ing`,
+    reason: '"Deny" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // resist
+  createRegexRule({
+    id: 'GI_resist_to',
+    category: 'grammar',
+    pattern: /\bresisted?\s+to\s+(\w+)/i,
+    suggestion: (m) => `resisted ${m[1]}ing`,
+    reason: '"Resist" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // finish
+  createRegexRule({
+    id: 'GI_finish_to',
+    category: 'grammar',
+    pattern: /\bfinished?\s+to\s+(\w+)/i,
+    suggestion: (m) => `finish${m[0].match(/finished/) ? 'ed' : ''} ${m[1]}ing`,
+    reason: '"Finish" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // mind
+  createRegexRule({
+    id: 'GI_mind_to',
+    category: 'grammar',
+    pattern: /\bminds?\s+to\s+(\w+)/i,
+    suggestion: (m) => `mind ${m[1]}ing`,
+    reason: '"Mind" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // miss
+  createRegexRule({
+    id: 'GI_miss_to',
+    category: 'grammar',
+    pattern: /\bmissed?\s+to\s+(\w+)/i,
+    suggestion: (m) => `miss${m[0].match(/missed/) ? 'ed' : ''} ${m[1]}ing`,
+    reason: '"Miss" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // quit
+  createRegexRule({
+    id: 'GI_quit_to',
+    category: 'grammar',
+    pattern: /\bquit\s+to\s+(\w+)/i,
+    suggestion: (m) => `quit ${m[1]}ing`,
+    reason: '"Quit" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // postpone / delay
+  createRegexRule({
+    id: 'GI_postpone_to',
+    category: 'grammar',
+    pattern: /\bpostponed?\s+to\s+(\w+)/i,
+    suggestion: (m) => `postponed ${m[1]}ing`,
+    reason: '"Postpone" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+  createRegexRule({
+    id: 'GI_delay_to',
+    category: 'grammar',
+    pattern: /\bdelayed?\s+to\s+(\w+)/i,
+    suggestion: (m) => `delayed ${m[1]}ing`,
+    reason: '"Delay" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // imagine
+  createRegexRule({
+    id: 'GI_imagine_to',
+    category: 'grammar',
+    pattern: /\bimagined?\s+to\s+(\w+)/i,
+    suggestion: (m) => `imagined ${m[1]}ing`,
+    reason: '"Imagine" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // risk
+  createRegexRule({
+    id: 'GI_risk_to',
+    category: 'grammar',
+    pattern: /\brisked?\s+to\s+(\w+)/i,
+    suggestion: (m) => `risked ${m[1]}ing`,
+    reason: '"Risk" is followed by a gerund (-ing form), not an infinitive.',
+  }),
+
+  // cannot help
+  createRegexRule({
+    id: 'GI_cant_help_to',
+    category: 'grammar',
+    pattern: /\bcan'?t\s+help\s+to\s+(\w+)/i,
+    suggestion: (m) => `can't help ${m[1]}ing`,
+    reason: '"Cannot help" is followed by a gerund, not an infinitive.',
+  }),
+
+  // ═══════════════════════════════════════════════
+  // SUBJUNCTIVE MOOD
+  // ═══════════════════════════════════════════════
+  createRegexRule({
+    id: 'GI_if_i_was',
+    category: 'grammar',
+    pattern: /\bif\s+I\s+was\b(?!\s+able|\s+going|\s+supposed|\s+trying|\s+planning|\s+hoping|\s+thinking|\s+looking)/i,
+    suggestion: 'if I were',
+    reason: 'Use the subjunctive "were" (not "was") in hypothetical "if" clauses.',
+  }),
+  createRegexRule({
+    id: 'GI_wish_i_was',
+    category: 'grammar',
+    pattern: /\bwish\s+(I|he|she|it)\s+was\b/i,
+    suggestion: (m) => `wish ${m[1]} were`,
+    reason: 'After "wish," use the subjunctive "were" instead of "was".',
+  }),
+  createRegexRule({
+    id: 'GI_as_if_was',
+    category: 'grammar',
+    pattern: /\bas\s+if\s+(I|he|she|it|he|they)\s+was\b/i,
+    suggestion: (m) => `as if ${m[1]} were`,
+    reason: 'After "as if," use the subjunctive "were" instead of "was".',
+  }),
+];

package/src/rules/categories/grammar-advanced.ts

@@ -0,0 +1,294 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const advancedGrammarRules: Rule[] = [
+  // Spacing Errors
+  createRegexRule({
+    id: 'double-space',
+    category: 'grammar',
+    pattern: /[^.](\s{2,})/g,
+    suggestion: ' ',
+    reason: 'Multiple spaces detected. Use single space.',
+  }),
+  createRegexRule({
+    id: 'space-before-punct',
+    category: 'grammar',
+    pattern: /\s+([.,!?;:])/g,
+    suggestion: (match) => match[1] || '',
+    reason: 'Remove space before punctuation.',
+  }),
+  createRegexRule({
+    id: 'no-space-after-punct',
+    category: 'grammar',
+    pattern: /([.,!?;:])([A-Z][a-z])/g,
+    suggestion: (match) => `${match[1] || ''} ${match[2] || ''}`,
+    reason: 'Add space after punctuation.',
+  }),
+
+  // Apostrophe Errors
+  createRegexRule({
+    id: 'its-possessive',
+    category: 'grammar',
+    pattern:
+      /\bits\s+(name|own|color|size|shape|kind|type|way|purpose|function|role|effect|impact|result|content|source|code|data|file|path|url|id|user|item|object|property|value|element|node|parent|child|sibling)\b/i,
+    suggestion: (match) => `it's ${match[1]}`,
+    reason: "Use 'it's' (contraction of 'it is') here.",
+  }),
+  createRegexRule({
+    id: 'youre-verb',
+    category: 'grammar',
+    pattern:
+      /\byour\s+(welcome|going|right|wrong|reading|writing|working|looking|sounding|feeling|thinking|doing|making|taking|getting|having|being|becoming|seeming|appearing)\b/i,
+    suggestion: (match) => `you're ${match[1]}`,
+    reason: "Use 'you're' (contraction of 'you are') here.",
+  }),
+  createRegexRule({
+    id: 'theyre-verb',
+    category: 'grammar',
+    pattern:
+      /\btheir\s+(going|coming|working|doing|making|taking|getting|having|being|becoming|seeming|looking|sounding|feeling|thinking)\b/i,
+    suggestion: (match) => `they're ${match[1]}`,
+    reason: "Use 'they're' (contraction of 'they are') here.",
+  }),
+
+  // That vs Which
+  createRegexRule({
+    id: 'which-no-comma',
+    category: 'grammar',
+    pattern: /([^,]\s+)which\s+(is|are|was|were|has|have|had|does|do|did)\b/i,
+    suggestion: (match) => `${match[1].trim()}, which ${match[2]}`,
+    reason: "Non-restrictive clauses need a comma before 'which'.",
+  }),
+
+  // Less vs Fewer
+  createRegexRule({
+    id: 'less-fewer',
+    category: 'grammar',
+    pattern:
+      /\bless\s+(items|things|people|words|sentences|paragraphs|pages|books|cars|houses|dogs|cats|students|teachers|errors|problems|questions|answers|ideas|concepts|rules|examples|cases|instances|occasions|times|days|weeks|months|years)\b/i,
+    suggestion: (match) => `fewer ${match[1]}`,
+    reason: "Use 'fewer' with countable nouns.",
+  }),
+
+  // Comma Splices (Requires more manual custom check logic)
+  {
+    id: 'comma-splice',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /\b([A-Z][^.]*?)\s*,\s+([A-Z][^.]*?[.!?])/g,
+    reason: 'Comma splice detected. Use a period, semicolon, or conjunction.',
+    suggestion: '',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const commaSpliceRegex = /\b([A-Z][^.]*?)\s*,\s+([A-Z][^.]*?[.!?])/g;
+      let match: RegExpExecArray | null;
+      while ((match = commaSpliceRegex.exec(text)) !== null) {
+        const clause1 = match[1]?.trim() || '';
+        const clause2 = match[2]?.trim() || '';
+        if (clause1.split(' ').length > 3 && clause2.split(' ').length > 3) {
+          issues.push({
+            id: `comma-splice-${match.index}`,
+            type: 'grammar',
+            original: `${clause1}, ${clause2}`,
+            suggestion: `${clause1}. ${clause2}`,
+            reason: 'Comma splice detected. Use a period, semicolon, or conjunction.',
+            offset: match.index,
+            length: match[0].length,
+          });
+        }
+      }
+      return issues;
+    },
+  },
+
+  // Double Negatives
+  {
+    id: 'double-negative',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /[^.!?]+[.!?]+/g,
+    reason: 'Double negative detected.',
+    suggestion: 'Remove one negative',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const negativeWords = [
+        "don't",
+        "doesn't",
+        "didn't",
+        "won't",
+        "wouldn't",
+        "couldn't",
+        "shouldn't",
+        "can't",
+        'cannot',
+        'no',
+        'not',
+        'never',
+        'nothing',
+        'nobody',
+        'nowhere',
+        'neither',
+        'nor',
+      ];
+      const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+      let currentIndex = 0;
+      sentences.forEach((sentence) => {
+        const lowerSentence = sentence.toLowerCase();
+        const foundNegatives = negativeWords.filter((word) => lowerSentence.includes(word));
+        if (foundNegatives.length >= 2) {
+          issues.push({
+            id: `double-neg-${currentIndex}`,
+            type: 'grammar',
+            original: sentence.trim(),
+            suggestion: 'Remove one negative',
+            reason: `Double negative detected: ${foundNegatives.join(', ')}. This may be unintentional.`,
+            offset: currentIndex,
+            length: sentence.length,
+          });
+        }
+        currentIndex += sentence.length;
+      });
+      return issues;
+    },
+  },
+
+  // Article Errors
+  {
+    id: 'article-a-an',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /\b(?:a|an)\s+\w+/gi,
+    reason: 'Article mismatch',
+    suggestion: '',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const vowelExceptions = new Set(['uni', 'use', 'usu', 'eur', 'one', 'once']);
+      const aBeforeVowelRegex = /\ba\s+([aeiou]\w*)\b/gi;
+      let match: RegExpExecArray | null;
+      while ((match = aBeforeVowelRegex.exec(text)) !== null) {
+        const nextWord = (match[1] || '').toLowerCase();
+        const isException = Array.from(vowelExceptions).some((ex) => nextWord.startsWith(ex));
+        if (!isException) {
+          issues.push({
+            id: `article-a-${match.index}`,
+            type: 'grammar',
+            original: match[0],
+            suggestion: `an ${match[1]}`,
+            reason: 'Use "an" before words that begin with a vowel sound.',
+            offset: match.index,
+            length: match[0].length,
+          });
+        }
+      }
+
+      const consonantExceptions = new Set(['hour', 'honest', 'honor', 'honour', 'heir', 'herb']);
+      const anBeforeConsonantRegex = /\ban\s+([bcdfghjklmnpqrstvwxyz]\w*)\b/gi;
+      while ((match = anBeforeConsonantRegex.exec(text)) !== null) {
+        const nextWord = (match[1] || '').toLowerCase();
+        const isException = Array.from(consonantExceptions).some((ex) => nextWord.startsWith(ex));
+        if (!isException) {
+          issues.push({
+            id: `article-an-${match.index}`,
+            type: 'grammar',
+            original: match[0],
+            suggestion: `a ${match[1]}`,
+            reason: 'Use "a" before words that begin with a consonant sound.',
+            offset: match.index,
+            length: match[0].length,
+          });
+        }
+      }
+      return issues;
+    },
+  },
+
+  // Missing Commas
+  {
+    id: 'intro-commas',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /(?:^|[.!?]\s+)(however|therefore|furthermore)\s+(?!,)([A-Za-z])/gi,
+    reason: 'Missing comma',
+    suggestion: '',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const introWords = [
+        'however',
+        'therefore',
+        'furthermore',
+        'moreover',
+        'nevertheless',
+        'meanwhile',
+        'consequently',
+        'additionally',
+        'similarly',
+        'accordingly',
+        'unfortunately',
+        'fortunately',
+        'finally',
+        'obviously',
+        'clearly',
+      ];
+
+      for (const word of introWords) {
+        const regex = new RegExp(`(?:^|[.!?]\\s+)${word}\\s+(?!,)([A-Za-z])`, 'gi');
+        let match: RegExpExecArray | null;
+        while ((match = regex.exec(text)) !== null) {
+          const wordStart = text.indexOf(word, match.index);
+          if (wordStart >= 0) {
+            issues.push({
+              id: `intro-comma-${wordStart}`,
+              type: 'grammar',
+              original: `${word} ${match[1]}`,
+              suggestion: `${word}, ${match[1]}`,
+              reason: `Add a comma after the introductory word "${word}".`,
+              offset: wordStart,
+              length: word.length + 2,
+            });
+          }
+        }
+      }
+      return issues;
+    },
+  },
+
+  // Sentence Fragments
+  {
+    id: 'sentence-fragments',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /^\s*(because|although|though|even though)/i,
+    reason: 'Sentence Fragment',
+    suggestion: 'This may be a sentence fragment. Add a main clause.',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+      let currentIndex = 0;
+      const subordinators =
+        /^\s*(because|although|though|even though|while|whereas|since|unless|until|if|when|whenever|wherever|after|before|as soon as|in order to|so that)\b/i;
+
+      for (const sentence of sentences) {
+        const trimmed = sentence.trim();
+        const match = subordinators.exec(trimmed);
+
+        if (match) {
+          const wordCount = trimmed.split(/\s+/).length;
+          const hasComma = trimmed.includes(',');
+          if (wordCount < 10 && !hasComma) {
+            issues.push({
+              id: `fragment-${currentIndex}`,
+              type: 'grammar',
+              original: trimmed,
+              suggestion: 'This may be a sentence fragment. Add a main clause.',
+              reason: `Sentences starting with "${match[1]}" need a main clause to be complete.`,
+              offset: currentIndex,
+              length: sentence.length,
+            });
+          }
+        }
+        currentIndex += sentence.length;
+      }
+      return issues;
+    },
+  },
+];