opengrammar-server 2.0.615350

package/src/rules/categories/adjectives-adverbs.ts

@@ -0,0 +1,152 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const adjectivesAdverbsRules: Rule[] = [
+  // ═══ Good/Well Confusion (AA_GDW) ═══
+  createRegexRule({
+    id: 'AA_GDW_plays',
+    category: 'grammar',
+    pattern:
+      /\b(plays|writes|performs|works|functions|runs|speaks|sings|dances|cooks|drives|reads|does|handles|communicates|operates|manages)\s+good\b/i,
+    suggestion: (m) => `${m[1]} well`,
+    reason: '"Good" is an adjective. Use the adverb "well" after action verbs.',
+  }),
+
+  // ═══ Adjective vs Adverb Confusion (AA_ADV) ═══
+  createRegexRule({
+    id: 'AA_ADV_beautiful',
+    category: 'grammar',
+    pattern: /\b(sings|plays|dances|writes|speaks|performs)\s+beautiful\b/i,
+    suggestion: (m) => `${m[1]} beautifully`,
+    reason: 'Use the adverb "beautifully" to modify a verb, not the adjective "beautiful".',
+  }),
+  createRegexRule({
+    id: 'AA_ADV_quick',
+    category: 'grammar',
+    pattern: /\b(runs|moves|walks|types|responds|reacts|acts|thinks|learns|grows)\s+quick\b/i,
+    suggestion: (m) => `${m[1]} quickly`,
+    reason: 'Use the adverb "quickly" to modify a verb, not the adjective "quick".',
+  }),
+  createRegexRule({
+    id: 'AA_ADV_bad',
+    category: 'grammar',
+    pattern: /\b(performs|writes|speaks|plays|behaves|acts|handles)\s+bad\b/i,
+    suggestion: (m) => `${m[1]} badly`,
+    reason: 'Use the adverb "badly" to modify a verb. "Bad" is an adjective.',
+  }),
+  createRegexRule({
+    id: 'AA_ADV_real',
+    category: 'grammar',
+    pattern:
+      /\b(real)\s+(good|nice|fast|quick|bad|hard|easy|big|small|important|interesting|beautiful|difficult)\b/i,
+    suggestion: (m) => `really ${m[2]}`,
+    reason: '"Real" is an adjective. Use the adverb "really" to modify another adjective.',
+  }),
+
+  // ═══ Double Comparatives (AA_CMP) ═══
+  createRegexRule({
+    id: 'AA_CMP_more_er',
+    category: 'grammar',
+    pattern:
+      /\bmore\s+(bigger|smaller|taller|shorter|faster|slower|older|younger|easier|harder|simpler|wider|narrower|louder|quieter|nicer|safer|cleaner|closer|newer|darker|brighter|stronger|weaker|smarter|cheaper|richer|poorer|thinner|thicker|longer|lighter|heavier|cooler|warmer|hotter|colder)\b/i,
+    suggestion: (m) => m[1] || '',
+    reason: 'Do not combine "more" with the -er comparative form. Use one or the other.',
+  }),
+  createRegexRule({
+    id: 'AA_CMP_most_est',
+    category: 'grammar',
+    pattern:
+      /\bmost\s+(biggest|smallest|tallest|shortest|fastest|slowest|oldest|youngest|easiest|hardest|simplest|widest|narrowest|loudest|quietest|nicest|safest|cleanest|closest|newest|darkest|brightest|strongest|weakest|smartest|cheapest|richest|poorest)\b/i,
+    suggestion: (m) => m[1] || '',
+    reason: 'Do not combine "most" with the -est superlative form. Use one or the other.',
+  }),
+
+  // ═══ Irregular Comparatives (AA_IRR) ═══
+  createRegexRule({
+    id: 'AA_IRR_gooder',
+    category: 'grammar',
+    pattern: /\bgooder\b/i,
+    suggestion: 'better',
+    reason: 'The comparative of "good" is "better", not "gooder".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_goodest',
+    category: 'grammar',
+    pattern: /\bgoodest\b/i,
+    suggestion: 'best',
+    reason: 'The superlative of "good" is "best", not "goodest".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_badder',
+    category: 'grammar',
+    pattern: /\bbadder\b/i,
+    suggestion: 'worse',
+    reason: 'The comparative of "bad" is "worse", not "badder".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_baddest',
+    category: 'grammar',
+    pattern: /\bbaddest\b/i,
+    suggestion: 'worst',
+    reason: 'The superlative of "bad" is "worst", not "baddest".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_more_good',
+    category: 'grammar',
+    pattern: /\bmore\s+good\b/i,
+    suggestion: 'better',
+    reason: 'The comparative of "good" is "better", not "more good".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_most_good',
+    category: 'grammar',
+    pattern: /\bmost\s+good\b/i,
+    suggestion: 'best',
+    reason: 'The superlative of "good" is "best", not "most good".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_more_bad',
+    category: 'grammar',
+    pattern: /\bmore\s+bad\b/i,
+    suggestion: 'worse',
+    reason: 'The comparative of "bad" is "worse", not "more bad".',
+  }),
+  createRegexRule({
+    id: 'AA_IRR_most_bad',
+    category: 'grammar',
+    pattern: /\bmost\s+bad\b/i,
+    suggestion: 'worst',
+    reason: 'The superlative of "bad" is "worst", not "most bad".',
+  }),
+
+  // ═══ Absolute Adjectives (AA_ABS) ═══
+  createRegexRule({
+    id: 'AA_ABS_unique',
+    category: 'style',
+    pattern:
+      /\b(very|more|most|extremely|really|somewhat|rather|slightly|fairly)\s+(unique|perfect|complete|dead|infinite|impossible|universal|absolute|essential|fatal|final|total|eternal|entire|supreme|unanimous|empty|equal|round|square|pregnant)\b/i,
+    suggestion: (m: RegExpExecArray) => m[2] || '',
+    reason:
+      'This is an absolute adjective and cannot logically be compared or intensified. Remove the modifier.',
+  }),
+
+  // ═══ Participial Adjectives: -ed vs -ing (AA_PAR) ═══
+  createRegexRule({
+    id: 'AA_PAR_boring',
+    category: 'grammar',
+    pattern:
+      /\b(I|he|she|we|they|you)\s+(am|is|are|was|were|feel|felt)\s+(boring|interesting|exciting|confusing|tiring|surprising|amazing|amusing|annoying|disappointing|embarrassing|exhausting|frightening|frustrating|inspiring|overwhelming|relaxing|satisfying|shocking|terrifying|thrilling|worrying)\b/i,
+    suggestion: (m) => `${m[1]} ${m[2]} ${(m[3] || '').replace(/ing$/, 'ed')}`,
+    reason:
+      'Use the -ed form when describing how a person FEELS. The -ing form describes what CAUSES the feeling.',
+  }),
+  createRegexRule({
+    id: 'AA_PAR_bored',
+    category: 'grammar',
+    pattern:
+      /\b(the\s+)?(movie|book|film|show|game|class|lesson|lecture|speech|presentation|talk|story|news|weather|trip|journey|experience|event|meeting|conversation|discussion|debate|task|job|work|project|assignment)\s+(is|are|was|were)\s+(bored|interested|excited|confused|tired|surprised|amazed|amused|annoyed|disappointed|embarrassed|exhausted|frightened|frustrated|inspired|overwhelmed|relaxed|satisfied|shocked|terrified|thrilled|worried)\b/i,
+    suggestion: (m) => `${m[1] || ''}${m[2]} ${m[3]} ${(m[4] || '').replace(/ed$/, 'ing')}`,
+    reason:
+      'Use the -ing form when describing something that CAUSES a feeling. The -ed form describes how people feel.',
+  }),
+];

package/src/rules/categories/articles.ts

@@ -0,0 +1,160 @@
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ════════════════════════════════════════════════════════
+ *  Article Rules — ART Module
+ *  a/an distinction + missing articles + extra articles
+ * ════════════════════════════════════════════════════════
+ */
+export const articleRules: Rule[] = [
+
+  // ─── A vs AN (vowel sound rule) ───
+  createRegexRule({
+    id: 'ART_a_vowel',
+    category: 'grammar',
+    // a before words starting with vowel SOUNDS (silent h)
+    pattern: /\ba\s+(honest|hour|heir|honor|honour|honorable|honourable|hourly|honesty|herb(\s|$))/i,
+    suggestion: (m) => `an ${m[1]}`,
+    reason: 'Use "an" before words with a vowel sound, including silent "h": "an honest person".',
+  }),
+  createRegexRule({
+    id: 'ART_an_consonant',
+    category: 'grammar',
+    pattern: /\ban\s+(hero|historic|historical|hotel|hospital|holiday|horror|horrible|hundred|huge|human|habit|hat|head|heart|help|hill|home|hope|house|hustle|hand|horse|hard|heavy|high|happy|hot|hole|hire)\b/i,
+    suggestion: (m) => `a ${m[1]}`,
+    reason: 'Use "a" before words with a consonant sound (including aspirated "h"): "a hero", "a hotel".',
+  }),
+  createRegexRule({
+    id: 'ART_an_unique',
+    category: 'grammar',
+    pattern: /\ban\s+(unique|user|union|uniform|united|unit|university|universe|usage|usual|utility|euro|European|euphemism|eulogy|ewe|one-)\b/i,
+    suggestion: (m) => `a ${m[1]}`,
+    reason: 'Use "a" before words starting with a "y" or "w" sound: "a unique", "a user".',
+  }),
+
+  // ─── DOUBLE ARTICLE ───
+  createRegexRule({
+    id: 'ART_double_the',
+    category: 'grammar',
+    pattern: /\bthe\s+the\b/i,
+    suggestion: 'the',
+    reason: 'Do not use "the" twice in a row.',
+  }),
+  createRegexRule({
+    id: 'ART_double_a',
+    category: 'grammar',
+    pattern: /\ba\s+a\b/i,
+    suggestion: 'a',
+    reason: 'Do not repeat the article "a".',
+  }),
+
+  // ─── CONFUSED ITS / IT'S ───
+  createRegexRule({
+    id: 'ART_its_contraction',
+    category: 'grammar',
+    pattern: /\bIts\s+(a|an|the|going|been|been|time|not|never|just|only|still|already|been)\b/,
+    suggestion: (m) => `It's ${m[1]}`,
+    reason: '"It\'s" (with apostrophe) is a contraction of "it is". "Its" is the possessive.',
+  }),
+  createRegexRule({
+    id: 'ART_its_contraction_lower',
+    category: 'grammar',
+    pattern: /\bits\s+(a|an|going|been|not|never|just|only|still|already|impossible|possible|clear|obvious|true|false|fine|okay|great|amazing|terrible|wonderful|awful|strange|weird|funny)\b/i,
+    suggestion: (m) => `it's ${m[1]}`,
+    reason: '"It\'s" (with apostrophe) is "it is". "Its" without apostrophe is the possessive.',
+  }),
+
+  // ─── THERE vs THEY'RE ───
+  createRegexRule({
+    id: 'ART_there_theyre',
+    category: 'grammar',
+    pattern: /\bThere\s+(going|coming|trying|waiting|planning|hoping|thinking|running|standing|sitting|looking|moving|working|playing|staying|leaving|arriving|calling|asking|telling|showing|helping|taking|making|doing)\b/,
+    suggestion: (m) => `They're ${m[1]}`,
+    reason: '"They\'re" means "they are". "There" refers to a place.',
+  }),
+  createRegexRule({
+    id: 'ART_there_theyre_lower',
+    category: 'grammar',
+    pattern: /\bthere\s+(going\s+to|coming\s+to|trying\s+to|waiting\s+for|planning\s+to|hoping\s+to)\b/i,
+    suggestion: (m) => `they're ${m[1]}`,
+    reason: '"They\'re" (they are) is different from "there" (a place) and "their" (possessive).',
+  }),
+
+  // ─── THEIR vs THERE ───
+  createRegexRule({
+    id: 'ART_their_there',
+    category: 'grammar',
+    pattern: /\bTheir\s+(were|was|is|are|has|have|had|will|would|could|should|might|may|must|can)\s+/,
+    suggestion: (m) => `There ${m[1]} `,
+    reason: '"There" refers to a location or introduces sentences. "Their" shows possession.',
+  }),
+  createRegexRule({
+    id: 'ART_their_there_lower',
+    category: 'grammar',
+    pattern: /\btheir\s+were\b/i,
+    suggestion: 'there were',
+    reason: '"There were" uses "there" (place/existence), not "their" (possessive).',
+  }),
+
+  // ─── PASSED vs PAST ───
+  createRegexRule({
+    id: 'ART_past_vs_passed',
+    category: 'grammar',
+    pattern: /\bshe\s+past\s+the\b/i,
+    suggestion: 'she passed the',
+    reason: '"Passed" is the verb (past tense of "pass"). "Past" is used as a preposition or noun.',
+  }),
+  createRegexRule({
+    id: 'ART_past_exam',
+    category: 'grammar',
+    pattern: /\b(he|she|I|they|we|you)\s+past\s+(the\s+)?(exam|test|interview|inspection|review|check)\b/i,
+    suggestion: (m) => `${m[1]} passed ${m[2] || ''}${m[3]}`,
+    reason: '"Passed" (verb) is the past tense of "pass". "Past" is not a verb.',
+  }),
+
+  // ─── DOUBLE COMPARATIVE ───
+  createRegexRule({
+    id: 'ART_most_worst',
+    category: 'grammar',
+    pattern: /\bthe\s+most\s+worst\b/i,
+    suggestion: 'the worst',
+    reason: '"Worst" is already a superlative. Do not add "most".',
+  }),
+  createRegexRule({
+    id: 'ART_more_prettier',
+    category: 'grammar',
+    pattern: /\bmore\s+(prettier|cleverer|wittier|funnier|happier|sadder|madder|thinner|fatter|taller|shorter|softer|harder|faster|slower|louder|quieter|richer|poorer|larger|smaller|bigger|younger|older|smarter|wiser|braver|kinder|nicer|sweeter)\b/i,
+    suggestion: (m) => m[1],
+    reason: `"${'"more prettier"'}" is a double comparative. "${'"Prettier"'}" is already the comparative form.`,
+  }),
+
+  // ─── REDUNDANT WORDS ───
+  createRegexRule({
+    id: 'ART_currently_now',
+    category: 'clarity',
+    pattern: /\bcurrently\s+now\b/i,
+    suggestion: 'currently',
+    reason: '"Currently" and "now" are redundant together. Use one.',
+  }),
+  createRegexRule({
+    id: 'ART_rsvp_please',
+    category: 'clarity',
+    pattern: /\bplease\s+RSVP\b/i,
+    suggestion: 'RSVP',
+    reason: '"RSVP" already means "please respond" (répondez s\'il vous plaît). "Please RSVP" is redundant.',
+  }),
+  createRegexRule({
+    id: 'ART_rsvp_to',
+    category: 'clarity',
+    pattern: /\bRSVP\s+to\s+(?:this|the)\s+(?:event|invitation|party|meeting)\b/i,
+    suggestion: (m) => m[0].replace(/RSVP\s+to/, 'RSVP for'),
+    reason: 'RSVP does not need "to" in formal usage.',
+  }),
+  createRegexRule({
+    id: 'ART_nodded_head',
+    category: 'clarity',
+    pattern: /\bnodded\s+(?:his|her|their|my|your|our)\s+head\b/i,
+    suggestion: 'nodded',
+    reason: '"Nodded" implies a head movement. "Nodded his head" is redundant.',
+  }),
+];

package/src/rules/categories/business-writing.ts

@@ -0,0 +1,250 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ═══════════════════════════════════════════════════
+ *  Business & Professional Writing (BW)
+ *  Empty openers, corporate bloat, weak verbs
+ * ═══════════════════════════════════════════════════
+ */
+export const businessWritingRules: Rule[] = [
+  // ═══ Empty Email Openers (BW_002) ═══
+  createRegexRule({
+    id: 'BW_writing_inform',
+    category: 'clarity',
+    pattern: /\bI\s+am\s+writing\s+to\s+inform\s+you\b/i,
+    suggestion: '(State the information directly)',
+    reason: '"I am writing to inform you" is an empty opener. Get to the point.',
+  }),
+  createRegexRule({
+    id: 'BW_email_let_know',
+    category: 'clarity',
+    pattern: /\bthis\s+email\s+is\s+to\s+let\s+you\s+know\b/i,
+    suggestion: '(State the information directly)',
+    reason: '"This email is to let you know" is filler. State the information directly.',
+  }),
+  createRegexRule({
+    id: 'BW_wanted_reach',
+    category: 'clarity',
+    pattern: /\bI\s+wanted\s+to\s+reach\s+out\b/i,
+    suggestion: '(State your purpose directly)',
+    reason: '"I wanted to reach out" is an empty opener. State your purpose directly.',
+  }),
+  createRegexRule({
+    id: 'BW_just_checking',
+    category: 'clarity',
+    pattern: /\bI\s+(am\s+)?just\s+checking\s+in\b/i,
+    suggestion: '(State your question directly)',
+    reason: '"Just checking in" is filler. Ask your question or state your purpose.',
+  }),
+  createRegexRule({
+    id: 'BW_touching_base',
+    category: 'clarity',
+    pattern: /\bI\s+(am\s+)?(just\s+)?touching\s+base\b/i,
+    suggestion: '(State your purpose)',
+    reason: '"Touching base" is vague corporate jargon. State your purpose clearly.',
+  }),
+  createRegexRule({
+    id: 'BW_hope_finds',
+    category: 'clarity',
+    pattern: /\bI\s+hope\s+this\s+(email|message)\s+finds\s+you\s+well\b/i,
+    suggestion: '(Skip or use a specific greeting)',
+    reason:
+      '"I hope this email finds you well" is a cliché opener. Get to the point or use a specific greeting.',
+  }),
+  createRegexRule({
+    id: 'BW_per_our',
+    category: 'clarity',
+    pattern: /\bper\s+our\s+(conversation|discussion|meeting|call|agreement|email)\b/i,
+    suggestion: (m) => `As we discussed in our ${m[1]}`,
+    reason: '"Per our..." is stiff. Try "As we discussed" or "Following our...".',
+  }),
+  createRegexRule({
+    id: 'BW_please_advise',
+    category: 'clarity',
+    pattern: /\bplease\s+advise\b/i,
+    suggestion: '(Ask a specific question)',
+    reason: '"Please advise" is vague. Ask a specific question instead.',
+  }),
+  createRegexRule({
+    id: 'BW_kindly_note',
+    category: 'clarity',
+    pattern: /\bkindly\s+note\s+that\b/i,
+    suggestion: 'Please note that',
+    reason: '"Kindly note" sounds overly formal. Use "Please note" or state the point directly.',
+  }),
+
+  // ═══ Weak/Corporate Verbs (BW_003) ═══
+  createRegexRule({
+    id: 'BW_utilize',
+    category: 'style',
+    pattern: /\butilize\b/i,
+    suggestion: 'use',
+    reason: '"Utilize" is unnecessarily complex. Use "use" — it means the same thing.',
+  }),
+  createRegexRule({
+    id: 'BW_implement',
+    category: 'style',
+    pattern:
+      /\bimplement\s+(a|an|the|this|that|our|your|new)\s+(solution|plan|strategy|system|process|policy|change)\b/i,
+    suggestion: (m) => `start ${m[1]} ${m[2]}`,
+    reason: '"Implement" is corporate-speak. Try "start", "begin", "put in place", or "carry out".',
+  }),
+  createRegexRule({
+    id: 'BW_facilitate',
+    category: 'style',
+    pattern: /\bfacilitate\b/i,
+    suggestion: 'help',
+    reason: '"Facilitate" is jargon. Use "help", "enable", "support", or "lead".',
+  }),
+  createRegexRule({
+    id: 'BW_commence',
+    category: 'style',
+    pattern: /\bcommence\b/i,
+    suggestion: 'begin',
+    reason: '"Commence" is unnecessarily formal. Use "begin" or "start".',
+  }),
+  createRegexRule({
+    id: 'BW_terminate',
+    category: 'style',
+    pattern: /\bterminate\s+(the|this|that|a|an|our|your|his|her|their)\b/i,
+    suggestion: (m) => `end ${m[1]}`,
+    reason: '"Terminate" is bureaucratic. Use "end", "stop", or "cancel".',
+  }),
+  createRegexRule({
+    id: 'BW_endeavor',
+    category: 'style',
+    pattern: /\bendeavou?r\b/i,
+    suggestion: 'try',
+    reason: '"Endeavor" is unnecessarily formal. Use "try" or "attempt".',
+  }),
+  createRegexRule({
+    id: 'BW_ascertain',
+    category: 'style',
+    pattern: /\bascertain\b/i,
+    suggestion: 'find out',
+    reason: '"Ascertain" is unnecessarily complex. Use "find out" or "determine".',
+  }),
+  createRegexRule({
+    id: 'BW_ameliorate',
+    category: 'style',
+    pattern: /\bameliorate\b/i,
+    suggestion: 'improve',
+    reason: '"Ameliorate" is unnecessarily complex. Use "improve".',
+  }),
+  createRegexRule({
+    id: 'BW_cognizant',
+    category: 'style',
+    pattern: /\bcognizant\b/i,
+    suggestion: 'aware',
+    reason: '"Cognizant" is unnecessarily complex. Use "aware".',
+  }),
+  createRegexRule({
+    id: 'BW_elucidate',
+    category: 'style',
+    pattern: /\belucidate\b/i,
+    suggestion: 'explain',
+    reason: '"Elucidate" is unnecessarily complex. Use "explain" or "clarify".',
+  }),
+  createRegexRule({
+    id: 'BW_expedite',
+    category: 'style',
+    pattern: /\bexpedite\b/i,
+    suggestion: 'speed up',
+    reason: '"Expedite" is corporate jargon. Use "speed up" or "accelerate".',
+  }),
+  createRegexRule({
+    id: 'BW_remuneration',
+    category: 'style',
+    pattern: /\bremuneration\b/i,
+    suggestion: 'pay',
+    reason: '"Remuneration" is unnecessarily formal. Use "pay", "salary", or "compensation".',
+  }),
+  createRegexRule({
+    id: 'BW_disseminate',
+    category: 'style',
+    pattern: /\bdisseminate\b/i,
+    suggestion: 'share',
+    reason: '"Disseminate" is unnecessarily complex. Use "share", "distribute", or "spread".',
+  }),
+  createRegexRule({
+    id: 'BW_promulgate',
+    category: 'style',
+    pattern: /\bpromulgate\b/i,
+    suggestion: 'announce',
+    reason: '"Promulgate" is legal/bureaucratic. Use "announce", "publish", or "declare".',
+  }),
+  createRegexRule({
+    id: 'BW_effectuate',
+    category: 'style',
+    pattern: /\beffectuate\b/i,
+    suggestion: 'carry out',
+    reason: '"Effectuate" is unnecessarily complex. Use "carry out" or "bring about".',
+  }),
+  createRegexRule({
+    id: 'BW_incentivize',
+    category: 'style',
+    pattern: /\bincentivize\b/i,
+    suggestion: 'encourage',
+    reason: '"Incentivize" is corporate jargon. Use "encourage", "motivate", or "reward".',
+  }),
+  createRegexRule({
+    id: 'BW_operationalize',
+    category: 'style',
+    pattern: /\boperationalize\b/i,
+    suggestion: 'put into practice',
+    reason: '"Operationalize" is corporate jargon. Use "put into practice" or "implement".',
+  }),
+  createRegexRule({
+    id: 'BW_onboard',
+    category: 'style',
+    pattern:
+      /\bonboard\s+(a|an|the|new|our)\s+(employee|team\s+member|hire|staff|colleague|person|candidate)\b/i,
+    suggestion: (m) => `welcome ${m[1]} ${m[2]}`,
+    reason: '"Onboard" as a verb is HR jargon. Try "welcome", "train", or "introduce".',
+  }),
+
+  // ═══ Polite Double Negatives (BW_004) ═══
+  createRegexRule({
+    id: 'BW_not_uncommon',
+    category: 'clarity',
+    pattern: /\bnot\s+uncommon\b/i,
+    suggestion: 'common',
+    reason: '"Not uncommon" is a double negative. Say "common" for clarity.',
+  }),
+  createRegexRule({
+    id: 'BW_not_unlike',
+    category: 'clarity',
+    pattern: /\bnot\s+unlike\b/i,
+    suggestion: 'similar to',
+    reason: '"Not unlike" is a double negative. Say "similar to" for clarity.',
+  }),
+  createRegexRule({
+    id: 'BW_not_insignificant',
+    category: 'clarity',
+    pattern: /\bnot\s+insignificant\b/i,
+    suggestion: 'significant',
+    reason: '"Not insignificant" is a double negative. Say "significant" directly.',
+  }),
+  createRegexRule({
+    id: 'BW_not_unreasonable',
+    category: 'clarity',
+    pattern: /\bnot\s+unreasonable\b/i,
+    suggestion: 'reasonable',
+    reason: '"Not unreasonable" is a double negative. Say "reasonable" directly.',
+  }),
+  createRegexRule({
+    id: 'BW_not_unimportant',
+    category: 'clarity',
+    pattern: /\bnot\s+unimportant\b/i,
+    suggestion: 'important',
+    reason: '"Not unimportant" is a double negative. Say "important" directly.',
+  }),
+  createRegexRule({
+    id: 'BW_not_infrequent',
+    category: 'clarity',
+    pattern: /\bnot\s+infrequent(ly)?\b/i,
+    suggestion: (m) => (m[1] ? 'frequently' : 'frequent'),
+    reason: '"Not infrequent" is a double negative. Say "frequent" directly.',
+  }),
+];

package/src/rules/categories/capitalization.ts

@@ -0,0 +1,79 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const capitalizationRules: Rule[] = [
+  // Standalone I
+  {
+    id: 'cap-i',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /(?:^|\s)(i)(?=\s|['’]m|[.,!?]|$)/g,
+    reason: 'The pronoun "I" should always be capitalized.',
+    suggestion: 'I',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const iRegex = /(?:^|\s)(i)(?=\s|['’]m|[.,!?]|$)/g;
+      let match: RegExpExecArray | null;
+      while ((match = iRegex.exec(text)) !== null) {
+        const matchIndex = match.index + match[0].indexOf('i');
+        issues.push({
+          id: `cap-i-${matchIndex}`,
+          type: 'grammar',
+          original: 'i',
+          suggestion: 'I',
+          reason: 'The pronoun "I" should always be capitalized.',
+          offset: matchIndex,
+          length: 1,
+        });
+      }
+      return issues;
+    },
+  },
+
+  // Days and Months
+  createRegexRule({
+    id: 'cap-date',
+    category: 'grammar',
+    pattern:
+      /\b(monday|tuesday|wednesday|thursday|friday|saturday|sunday|january|february|march|april|may|june|july|august|september|october|november|december)\b/g,
+    suggestion: (m) => m[1].charAt(0).toUpperCase() + m[1].slice(1),
+    reason: 'Days of the week and months should be capitalized.',
+  }),
+
+  // Common Proper Nouns
+  createRegexRule({
+    id: 'cap-proper-noun',
+    category: 'grammar',
+    pattern:
+      /\b(swadhin|dhaka|john|mary|london|paris|america|india|bangladesh|google|microsoft|apple|facebook)\b/g,
+    suggestion: (m) => m[1].charAt(0).toUpperCase() + m[1].slice(1),
+    reason: 'Proper nouns, names, and places should be capitalized.',
+  }),
+
+  // First letter of sentences
+  {
+    id: 'cap-sentence-start',
+    type: 'regex',
+    category: 'grammar',
+    pattern: /(?:^|[.!?]\s+)([a-z])/g,
+    reason: 'The first word of a sentence should be capitalized.',
+    suggestion: '',
+    check: (text: string): Issue[] => {
+      const issues: Issue[] = [];
+      const sentenceStartRegex = /(?:^|[.!?]\s+)([a-z])/g;
+      let match: RegExpExecArray | null;
+      while ((match = sentenceStartRegex.exec(text)) !== null) {
+        issues.push({
+          id: `cap-start-${match.index}`,
+          type: 'grammar',
+          original: match[1],
+          suggestion: match[1].toUpperCase(),
+          reason: 'The first word of a sentence should be capitalized.',
+          offset: match.index + match[0].lastIndexOf(match[1]),
+          length: 1,
+        });
+      }
+      return issues;
+    },
+  },
+];