opengrammar-server 2.0.615350

package/src/rules/categories/confused-words.ts

@@ -0,0 +1,219 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ═══════════════════════════════════════════════════
+ *  Commonly Confused Words (CW)
+ *  Contextual detection of homophones & near-matches
+ * ═══════════════════════════════════════════════════
+ */
+export const confusedWordsRules: Rule[] = [
+  // ═══ affect vs effect ═══
+  createRegexRule({
+    id: 'CW_affect_noun',
+    category: 'grammar',
+    pattern:
+      /\b(a|an|the|this|that|its|no|any|great|big|huge|major|significant|positive|negative|profound|lasting|adverse|direct|indirect|overall|desired|intended|net|cumulative)\s+affect\b/i,
+    suggestion: (m) => `${m[1]} effect`,
+    reason: '"Affect" is usually a verb (to influence). The noun form is "effect" (a result).',
+  }),
+  createRegexRule({
+    id: 'CW_effect_verb',
+    category: 'grammar',
+    pattern:
+      /\b(will|would|can|could|may|might|shall|should|did|does|do|didn't|doesn't|won't|cannot)\s+effect\s+(my|your|his|her|our|their|the|a|an|this|that)\b/i,
+    suggestion: (m) => `${m[1]} affect ${m[2]}`,
+    reason: '"Effect" as a verb means "to bring about". You likely mean "affect" (to influence).',
+  }),
+
+  // ═══ accept vs except ═══
+  createRegexRule({
+    id: 'CW_except_verb',
+    category: 'grammar',
+    pattern:
+      /\b(I|we|they|he|she|you|will|would|can|please)\s+except\s+(your|the|this|that|a|an|my|his|her|our|their)\s+(offer|invitation|apology|terms|conditions|proposal|gift|award|position|responsibility|challenge|nomination|request)\b/i,
+    suggestion: (m) => `${m[1]} accept ${m[2]} ${m[3]}`,
+    reason: '"Except" means "excluding". You likely mean "accept" (to receive).',
+  }),
+  createRegexRule({
+    id: 'CW_accept_prep',
+    category: 'grammar',
+    pattern: /\beveryone\s+accept\b/i,
+    suggestion: 'everyone except',
+    reason: '"Accept" means to receive. You likely mean "except" (excluding).',
+  }),
+
+  // ═══ loose vs lose ═══
+  createRegexRule({
+    id: 'CW_loose_verb',
+    category: 'grammar',
+    pattern:
+      /\b(will|would|can|could|might|may|don't|didn't|doesn't|won't|cannot|going\s+to|afraid\s+to|about\s+to|hate\s+to|want\s+to|don't\s+want\s+to)\s+loose\b/i,
+    suggestion: (m) => `${m[1]} lose`,
+    reason: '"Loose" means not tight. The verb meaning "to misplace/fail" is "lose".',
+  }),
+  createRegexRule({
+    id: 'CW_loose_money',
+    category: 'grammar',
+    pattern:
+      /\bloose\s+(money|weight|hope|faith|interest|patience|sight|track|control|touch|time|ground|sleep|focus|balance|confidence|consciousness|grip|footing|temper|mind)\b/i,
+    suggestion: (m) => `lose ${m[1]}`,
+    reason: '"Loose" means not tight. You likely mean "lose" (to misplace/fail to keep).',
+  }),
+
+  // ═══ than vs then ═══
+  createRegexRule({
+    id: 'CW_then_compare',
+    category: 'grammar',
+    pattern:
+      /\b(more|less|better|worse|greater|fewer|higher|lower|bigger|smaller|faster|slower|older|younger|easier|harder|stronger|weaker|longer|shorter|wider|taller|cheaper|richer|smarter|nicer)\s+then\b/i,
+    suggestion: (m) => `${m[1]} than`,
+    reason: 'Use "than" for comparisons. "Then" refers to time.',
+  }),
+  createRegexRule({
+    id: 'CW_then_rather',
+    category: 'grammar',
+    pattern: /\brather\s+then\b/i,
+    suggestion: 'rather than',
+    reason: 'The correct phrase is "rather than", not "rather then".',
+  }),
+  createRegexRule({
+    id: 'CW_then_other',
+    category: 'grammar',
+    pattern: /\bother\s+then\b/i,
+    suggestion: 'other than',
+    reason: 'The correct phrase is "other than", not "other then".',
+  }),
+
+  // ═══ whose vs who's ═══
+  createRegexRule({
+    id: 'CW_whos_poss',
+    category: 'grammar',
+    pattern:
+      /\bwho's\s+(car|house|book|phone|computer|bag|dog|cat|idea|fault|problem|responsibility|job|turn|birthday|name|number|address)\b/i,
+    suggestion: (m) => `whose ${m[1]}`,
+    reason: '"Who\'s" means "who is" or "who has". For possession, use "whose".',
+  }),
+  createRegexRule({
+    id: 'CW_whose_contraction',
+    category: 'grammar',
+    pattern:
+      /\bwhose\s+(going|coming|doing|making|getting|trying|looking|working|playing|running|been|is|are|was|the\s+one)\b/i,
+    suggestion: (m) => `who's ${m[1]}`,
+    reason: '"Whose" shows possession. You likely mean "who\'s" (who is/who has).',
+  }),
+
+  // ═══ weather vs whether ═══
+  createRegexRule({
+    id: 'CW_weather_if',
+    category: 'grammar',
+    pattern: /\bweather\s+(or\s+not|I|you|he|she|it|we|they|the|this|that|to)\b/i,
+    suggestion: (m) => `whether ${m[1]}`,
+    reason: '"Weather" refers to climate. For "if", use "whether".',
+  }),
+
+  // ═══ dessert vs desert ═══
+  createRegexRule({
+    id: 'CW_desert_food',
+    category: 'grammar',
+    pattern:
+      /\b(for|ate|had|ordered|served|eating|delicious|chocolate|ice\s+cream|cake)\s+desert\b/i,
+    suggestion: (m) => `${m[1]} dessert`,
+    reason:
+      '"Desert" is arid land. The sweet food is "dessert" (two s\'s — because you want more!).',
+  }),
+
+  // ═══ advise vs advice ═══
+  createRegexRule({
+    id: 'CW_advice_verb',
+    category: 'grammar',
+    pattern: /\b(I|we|they|he|she|you|would|will|can|please|let\s+me|should)\s+advice\b/i,
+    suggestion: (m) => `${m[1]} advise`,
+    reason: '"Advice" is a noun. The verb form is "advise".',
+  }),
+  createRegexRule({
+    id: 'CW_advise_noun',
+    category: 'grammar',
+    pattern:
+      /\b(some|good|bad|my|your|his|her|their|our|excellent|terrible|a\s+piece\s+of|any)\s+advise\b/i,
+    suggestion: (m) => `${m[1]} advice`,
+    reason: '"Advise" is a verb. The noun form is "advice".',
+  }),
+
+  // ═══ complement vs compliment ═══
+  createRegexRule({
+    id: 'CW_compliment_enhance',
+    category: 'grammar',
+    pattern: /\b(perfectly|nicely|well)\s+compliments\b/i,
+    suggestion: (m) => `${m[1]} complements`,
+    reason: '"Compliment" means praise. "Complement" means to enhance/complete.',
+  }),
+
+  // ═══ principal vs principle ═══
+  createRegexRule({
+    id: 'CW_principle_person',
+    category: 'grammar',
+    pattern: /\b(school|the)\s+principle\b/i,
+    suggestion: (m) => `${m[1]} principal`,
+    reason: 'The head of a school is the "principal". A "principle" is a rule or belief.',
+  }),
+
+  // ═══ ensure vs insure ═══
+  createRegexRule({
+    id: 'CW_insure_certain',
+    category: 'grammar',
+    pattern: /\binsure\s+that\b/i,
+    suggestion: 'ensure that',
+    reason: '"Insure" means financial protection. For "make certain", use "ensure".',
+  }),
+
+  // ═══ elicit vs illicit ═══
+  createRegexRule({
+    id: 'CW_illicit_verb',
+    category: 'grammar',
+    pattern:
+      /\b(to|will|would|can|could|trying\s+to|designed\s+to|intended\s+to|meant\s+to)\s+illicit\b/i,
+    suggestion: (m) => `${m[1]} elicit`,
+    reason: '"Illicit" means illegal (adjective). The verb "to draw out" is "elicit".',
+  }),
+
+  // ═══ precede vs proceed ═══
+  createRegexRule({
+    id: 'CW_proceed_before',
+    category: 'grammar',
+    pattern: /\bproceeds?\s+(the|a|this|each|every|any)\b/i,
+    suggestion: (m) => `precedes ${m[1]}`,
+    reason: '"Proceed" means to move forward. "Precede" means to come before.',
+  }),
+
+  // ═══ cite vs site ═══
+  createRegexRule({
+    id: 'CW_site_reference',
+    category: 'grammar',
+    pattern:
+      /\b(please|must|should|need\s+to|remember\s+to|don't\s+forget\s+to)\s+site\s+(the|your|this|a|an|all|every|each)\s+(source|reference|work|paper|article|study|author|book|evidence|example|data|finding|research|statistic|quote|passage)\b/i,
+    suggestion: (m) => `${m[1]} cite ${m[2]} ${m[3]}`,
+    reason: '"Site" is a location. To reference a source, use "cite".',
+  }),
+
+  // ═══ allusion vs illusion ═══
+  createRegexRule({
+    id: 'CW_illusion_reference',
+    category: 'grammar',
+    pattern:
+      /\b(made|makes?\s+an?|contains?\s+an?|biblical|literary|cultural|historical)\s+illusion\b/i,
+    suggestion: (m) => `${m[1]} allusion`,
+    reason: '"Illusion" is a false perception. An indirect reference is an "allusion".',
+  }),
+
+  // ═══ literally misuse ═══
+  createRegexRule({
+    id: 'CW_literally',
+    category: 'style',
+    pattern:
+      /\bliterally\s+(dying|exploding|on\s+fire|killing\s+me|the\s+best|the\s+worst|died|killed|melting|starving|freezing|screaming|crying|shaking|bursting|insane|crazy|dead)\b/i,
+    suggestion: (m) => `figuratively ${m[1]}`,
+    reason:
+      '"Literally" means "actually/in reality". If you\'re using hyperbole, the word you want is "figuratively" — or simply drop "literally".',
+  }),
+];

package/src/rules/categories/conjunctions.ts

@@ -0,0 +1,176 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const conjunctionRules: Rule[] = [
+  // ═══ Redundant Conjunctions (CJ_RED) ═══
+  createRegexRule({
+    id: 'CJ_RED_although_but',
+    category: 'grammar',
+    pattern: /\b(although|though|even\s+though)\b([^.]*?)\bbut\b/i,
+    suggestion: (m) => `${m[1]}${m[2]}`,
+    reason: '"Although" and "but" are redundant together. Remove one of them.',
+  }),
+  createRegexRule({
+    id: 'CJ_RED_because_so',
+    category: 'grammar',
+    pattern: /\bbecause\b([^.]*?)\bso\b/i,
+    suggestion: (m) => `because${m[1]}`,
+    reason: '"Because" and "so" are redundant together. Remove one of them.',
+  }),
+  createRegexRule({
+    id: 'CJ_RED_despite_but',
+    category: 'grammar',
+    pattern: /\b(despite|in\s+spite\s+of)\b([^.]*?)\bbut\b/i,
+    suggestion: (m) => `${m[1]}${m[2]}`,
+    reason: '"Despite" and "but" are redundant together. Remove "but".',
+  }),
+
+  // ═══ Wordy Conjunction Replacements (CJ_WRD) ═══
+  createRegexRule({
+    id: 'CJ_WRD_due_to',
+    category: 'clarity',
+    pattern: /\bdue\s+to\s+the\s+fact\s+that\b/i,
+    suggestion: 'because',
+    reason: '"Due to the fact that" is wordy. Use "because" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_spite',
+    category: 'clarity',
+    pattern: /\bin\s+spite\s+of\s+the\s+fact\s+that\b/i,
+    suggestion: 'although',
+    reason: '"In spite of the fact that" is wordy. Use "although" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_regardless',
+    category: 'clarity',
+    pattern: /\bregardless\s+of\s+the\s+fact\s+that\b/i,
+    suggestion: 'although',
+    reason: '"Regardless of the fact that" is wordy. Use "although" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_for_purpose',
+    category: 'clarity',
+    pattern: /\bfor\s+the\s+purpose\s+of\b/i,
+    suggestion: 'to',
+    reason: '"For the purpose of" is wordy. Use "to" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_order',
+    category: 'clarity',
+    pattern: /\bin\s+order\s+to\b/i,
+    suggestion: 'to',
+    reason: '"In order to" is wordy. Use "to" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_event',
+    category: 'clarity',
+    pattern: /\bin\s+the\s+event\s+that\b/i,
+    suggestion: 'if',
+    reason: '"In the event that" is wordy. Use "if" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_light',
+    category: 'clarity',
+    pattern: /\bin\s+light\s+of\s+the\s+fact\s+that\b/i,
+    suggestion: 'because',
+    reason: '"In light of the fact that" is wordy. Use "because" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_exception',
+    category: 'clarity',
+    pattern: /\bwith\s+the\s+exception\s+of\b/i,
+    suggestion: 'except',
+    reason: '"With the exception of" is wordy. Use "except" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_at_this_point',
+    category: 'clarity',
+    pattern: /\bat\s+this\s+point\s+in\s+time\b/i,
+    suggestion: 'now',
+    reason: '"At this point in time" is wordy. Use "now" or "currently" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_the_near',
+    category: 'clarity',
+    pattern: /\bin\s+the\s+near\s+future\b/i,
+    suggestion: 'soon',
+    reason: '"In the near future" is wordy. Use "soon" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_at_present',
+    category: 'clarity',
+    pattern: /\bat\s+the\s+present\s+time\b/i,
+    suggestion: 'now',
+    reason: '"At the present time" is wordy. Use "now" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_on_account',
+    category: 'clarity',
+    pattern: /\bon\s+account\s+of\s+the\s+fact\s+that\b/i,
+    suggestion: 'because',
+    reason: '"On account of the fact that" is wordy. Use "because" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_by_means',
+    category: 'clarity',
+    pattern: /\bby\s+means\s+of\b/i,
+    suggestion: 'by',
+    reason: '"By means of" is wordy. Use "by" or "using" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_in_regard',
+    category: 'clarity',
+    pattern: /\bin\s+regard\s+to\b/i,
+    suggestion: 'regarding',
+    reason: '"In regard to" is wordy. Use "regarding" or "about" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_with_respect',
+    category: 'clarity',
+    pattern: /\bwith\s+respect\s+to\b/i,
+    suggestion: 'regarding',
+    reason: '"With respect to" is wordy. Use "regarding" or "about" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_has_ability',
+    category: 'clarity',
+    pattern: /\bhas\s+the\s+ability\s+to\b/i,
+    suggestion: 'can',
+    reason: '"Has the ability to" is wordy. Use "can" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_is_able',
+    category: 'clarity',
+    pattern: /\bis\s+able\s+to\b/i,
+    suggestion: 'can',
+    reason: '"Is able to" is wordy. Use "can" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_make_use',
+    category: 'clarity',
+    pattern: /\bmake\s+use\s+of\b/i,
+    suggestion: 'use',
+    reason: '"Make use of" is wordy. Use "use" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_take_into',
+    category: 'clarity',
+    pattern: /\btake\s+into\s+consideration\b/i,
+    suggestion: 'consider',
+    reason: '"Take into consideration" is wordy. Use "consider" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_a_large_number',
+    category: 'clarity',
+    pattern: /\ba\s+large\s+number\s+of\b/i,
+    suggestion: 'many',
+    reason: '"A large number of" is wordy. Use "many" instead.',
+  }),
+  createRegexRule({
+    id: 'CJ_WRD_sufficient_amount',
+    category: 'clarity',
+    pattern: /\ba\s+sufficient\s+amount\s+of\b/i,
+    suggestion: 'enough',
+    reason: '"A sufficient amount of" is wordy. Use "enough" instead.',
+  }),
+];

package/src/rules/categories/dangling-modifiers.ts

@@ -0,0 +1,123 @@
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ════════════════════════════════════════════════════════════
+ *  Dangling Modifier Rules — DM Module
+ *
+ *  A dangling modifier is a word or phrase that describes
+ *  something that is implied but not explicitly stated.
+ *  The classic test: "who is doing the [verb]ing?"
+ *  If the answer doesn't match the subject of the main clause → dangling.
+ *
+ *  Examples:
+ *    "Walking down the street, the rain started." (rain can't walk)
+ *    "Having finished the essay, the TV was turned on." (TV didn't finish)
+ *    "To improve your writing, grammar must be studied." (grammar isn't improving)
+ * ════════════════════════════════════════════════════════════
+ */
+export const danglingModifierRules: Rule[] = [
+
+  // ═══════════════════════════════════════════════════════
+  // 1. PRESENT PARTICIPLE PHRASES (Walking/Running/etc. + ,)
+  //    Pattern: gerund phrase → comma → inanimate/wrong subject
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_PRES_PART_inanimate',
+    category: 'grammar',
+    pattern: /^(Walking|Running|Driving|Looking|Talking|Working|Sitting|Standing|Playing|Eating|Drinking|Reading|Writing|Watching|Thinking|Speaking|Listening|Waiting|Sleeping|Swimming|Flying|Climbing|Jumping|Dancing|Singing|Laughing|Crying|Shopping|Cooking|Cleaning|Fixing|Building|Breaking|Opening|Closing|Carrying|Pushing|Pulling|Lifting|Drawing|Painting|Teaching|Studying|Planning|Deciding|Moving|Turning)\s+[^,]+,\s+(the\s+(?!speaker|author|writer|narrator|user|reader|person|man|woman|student|teacher|team|police|doctor|nurse|officer|employee|manager|owner|player|customer|client|victim)\w+|a\s+\w+|it\s+|there\s+|this\s+|that\s+)\b/i,
+    suggestion: (m) => {
+      const verb = m[1].toLowerCase();
+      const gerund = verb.endsWith('ing') ? verb : verb + 'ing';
+      return `[Subject who is ${gerund}], ${m[2].trim()}...`;
+    },
+    reason: 'Dangling modifier: clarify who is performing the action at the start of the sentence. The participial phrase must describe the main clause\'s subject.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 2. PERFECT PARTICIPIAL PHRASES (Having + past participle)
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_PERF_PART_having',
+    category: 'grammar',
+    pattern: /^Having\s+(?:just\s+|recently\s+|finally\s+|already\s+|nearly\s+|almost\s+)?(finished|completed|done|eaten|drunk|written|read|watched|seen|heard|found|met|left|arrived|returned|decided|chosen|learned|studied|prepared|reviewed|checked|fixed|broken|opened|closed|taken|given|sent|received|made|built|drawn|painted|bought|sold|lost|won|started|ended|begun|stopped|tried|used|worked|gone|come|got|become|felt|thought|said|told|called|visited|helped|supported|managed|organized|set|put|run)\s+[^,]+,\s+(the\s+(?!author|speaker|writer|subject|team|group|reader|narrator)\w+|a\s+\w+|it\s+|there\s+|this\s+|that\s+)/i,
+    suggestion: (m) => `Having ${m[1]} [what], [the person who did it] ...`,
+    reason: 'Dangling modifier: "Having [done something]..." must describe the subject of the main clause. Clarify who performed this action.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 3. INFINITIVE PHRASES (To + verb + ..., passive main clause)
+  //    "To improve writing, grammar must be studied." ← dangling
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_INF_passive',
+    category: 'grammar',
+    pattern: /^To\s+(\w+)\s+(?:your\s+|the\s+|a\s+|an\s+|our\s+|their\s+|its\s+|one'?s\s+)?\w+[^,]*,\s+\w+\s+(must\s+be|should\s+be|needs?\s+to\s+be|has?\s+to\s+be|will\s+be|can\s+be|could\s+be|would\s+be|is\s+being|was\s+being|are\s+being)\s+/i,
+    suggestion: (m) => `To ${m[1]} ..., [you/one] should ... (avoid passive voice after an infinitive phrase)`,
+    reason: 'Dangling infinitive: "To [verb]..." should be followed by the person performing the action, not a passive clause.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 4. "BEING" PHRASES
+  //    "Being a student, the exam was stressful." ← dangling
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_BEING_phrase',
+    category: 'grammar',
+    pattern: /^Being\s+(?:a\s+|an\s+|the\s+)?(?:young\s+|old\s+|good\s+|new\s+|senior\s+|junior\s+)?\w+[^,]*,\s+(the\s+(?!author|speaker|writer|person|team)\w+|a\s+\w+|it\s+|this\s+|that\s+)/i,
+    suggestion: (m) => `Being [description], [the person] ... (not "${m[1].trim()}")`,
+    reason: 'Dangling modifier: "Being ..." should describe the subject of the main clause, not a different object.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 5. "AFTER/BEFORE/WHILE + GERUND" PHRASES (passive main clause)
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_PREP_GERUND_passive',
+    category: 'grammar',
+    pattern: /^(After|Before|While|Upon|When)\s+(\w+ing)\s+[^,]+,\s+(?:the\s+|a\s+|an\s+)\w+\s+(was|were|is|are|will\s+be|has\s+been|have\s+been|had\s+been)\s+(?:given|awarded|presented|offered|provided|sent|told|shown|handed|issued|assigned|denied|refused|granted)\b/i,
+    suggestion: (m) => `${m[1]} ${m[2]} ..., [the person] received / was given...`,
+    reason: 'Dangling modifier: the participial phrase implies a subject that differs from the passive main clause\'s subject.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 6. "WHEN/WHILE" OMITTED SUBJECT
+  //    "When cooking, the smoke alarm went off." ← dangling
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_WHEN_omitted',
+    category: 'grammar',
+    pattern: /^(When|While|Whenever)\s+(cooking|baking|driving|sleeping|running|swimming|exercising|showering|bathing|reading|studying|working|traveling|hiking|climbing|skiing|playing|drinking|eating)\s*,\s+(the\s+(?!person|speaker|author|user|student|teacher)\w+|a\s+\w+|it\s+|no\s+one|nothing|everyone|everything)\s+(went|started|began|happened|occurred|was|appeared|seemed|became|felt)\b/i,
+    suggestion: (m) => `${m[1]} [someone was] ${m[2]}ing, ${m[3]} ${m[4]}...`,
+    reason: 'Dangling modifier: add an explicit subject ("When I was cooking..." not "When cooking, the alarm...").',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 7. AS A + NOUN PHRASES
+  //    "As a student, the book was assigned to us." ← dangling
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_AS_A_phrase',
+    category: 'grammar',
+    pattern: /^As\s+(?:a|an|the)\s+\w+[^,]*,\s+(the\s+(?!author|speaker|writer|narrator|person|teacher|student|team|group|doctor|manager|officer)\w+|a\s+\w+|it\s+|this\s+|that\s+)\s+(was|were|is|are|has\s+been|had\s+been|will\s+be|needs?\s+to)\b/i,
+    suggestion: (m) => `As [the role], [I/we/one] ... (not "${m[1].trim()} ${m[2]}")`,
+    reason: 'Dangling modifier: "As a [role]..." must describe the subject of the main clause — the subject should be the person in that role.',
+  }),
+
+  // ═══════════════════════════════════════════════════════
+  // 8. "ONLY" MISPLACEMENT
+  // ═══════════════════════════════════════════════════════
+  createRegexRule({
+    id: 'DM_ONLY_misplaced_time',
+    category: 'grammar',
+    pattern: /\b(I|he|she|they|we|you)\s+only\s+(eat|ate|drink|drank|work|worked|go|went|use|used|spend|spent|visit|visited|call|called|meet|met|write|wrote|read|run|play|played|watch|watched)\s+(\w+)\s+on\b/i,
+    suggestion: (m) => `${m[1]} ${m[2]} ${m[3]} only on`,
+    reason: 'Misplaced "only": move it directly before the word it modifies. E.g., "I eat vegetables only on Mondays."',
+  }),
+  createRegexRule({
+    id: 'DM_ONLY_misplaced_verb',
+    category: 'grammar',
+    pattern: /\b(I|he|she|they|we|you)\s+only\s+(need|needed|want|wanted|have|had|like|liked|love|loved|hate|hated|prefer|preferred|do|did|can|could|will|would|should|must|may|might)\s+(?:to\s+)?(\w+)\s+(because|when|if|since|after|although)\b/i,
+    suggestion: (m) => `${m[1]} ${m[2]} ${m[3]} only ${m[4]} — or move "only" before what it modifies`,
+    reason: 'Misplaced "only": position it right before the word it logically modifies to avoid ambiguity.',
+  }),
+];