opengrammar-server 2.0.644277

package/src/rules/categories/style-tone.ts

@@ -0,0 +1,511 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ═══════════════════════════════════════════════════
+ *  Style & Tone (ST)
+ *  Wordiness, hedging, filler, nominalizations, clichés
+ * ═══════════════════════════════════════════════════
+ */
+export const styleToneRules: Rule[] = [
+  // ═══ Redundant Pairs (ST_001) ═══
+  createRegexRule({
+    id: 'ST_RP_each_every',
+    category: 'clarity',
+    pattern: /\beach\s+and\s+every\b/i,
+    suggestion: 'every',
+    reason: '"Each and every" is redundant. Use "each" or "every".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_first_foremost',
+    category: 'clarity',
+    pattern: /\bfirst\s+and\s+foremost\b/i,
+    suggestion: 'first',
+    reason: '"First and foremost" is redundant. Use "first".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_null_void',
+    category: 'clarity',
+    pattern: /\bnull\s+and\s+void\b/i,
+    suggestion: 'void',
+    reason: '"Null and void" is redundant in general writing. Use "void" or "invalid".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_true_accurate',
+    category: 'clarity',
+    pattern: /\btrue\s+and\s+accurate\b/i,
+    suggestion: 'accurate',
+    reason: '"True and accurate" is redundant. Use "accurate".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_any_all',
+    category: 'clarity',
+    pattern: /\bany\s+and\s+all\b/i,
+    suggestion: 'all',
+    reason: '"Any and all" is redundant. Use "all" or "any".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_full_complete',
+    category: 'clarity',
+    pattern: /\bfull\s+and\s+complete\b/i,
+    suggestion: 'complete',
+    reason: '"Full and complete" is redundant. Use "complete".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_aid_abet',
+    category: 'clarity',
+    pattern: /\baid\s+and\s+abet\b/i,
+    suggestion: 'aid',
+    reason: '"Aid and abet" is a legal doublet. In general writing, use "aid" or "help".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_cease_desist',
+    category: 'clarity',
+    pattern: /\bcease\s+and\s+desist\b/i,
+    suggestion: 'cease',
+    reason: '"Cease and desist" is a legal doublet. In general writing, use "stop".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_one_only',
+    category: 'clarity',
+    pattern: /\bone\s+and\s+only\b/i,
+    suggestion: 'only',
+    reason: '"One and only" is redundant outside emphasis.',
+  }),
+  createRegexRule({
+    id: 'ST_RP_hopes_dreams',
+    category: 'clarity',
+    pattern: /\bhopes\s+and\s+dreams\b/i,
+    suggestion: 'aspirations',
+    reason: '"Hopes and dreams" is a cliché. Consider "aspirations" or "ambitions".',
+  }),
+  createRegexRule({
+    id: 'ST_RP_basic_fundamental',
+    category: 'clarity',
+    pattern: /\bbasic\s+and\s+fundamental\b/i,
+    suggestion: 'fundamental',
+    reason: '"Basic and fundamental" is redundant.',
+  }),
+  createRegexRule({
+    id: 'ST_RP_plain_simple',
+    category: 'clarity',
+    pattern: /\bplain\s+and\s+simple\b/i,
+    suggestion: 'simply',
+    reason: '"Plain and simple" is redundant. Use "simply".',
+  }),
+
+  // ═══ Nominalizations — Hidden Verbs (ST_005) ═══
+  createRegexRule({
+    id: 'ST_NOM_decision',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+decision\b/i,
+    suggestion: 'decide',
+    reason: 'Nominalizations hide the action. Use "decide" instead of "make a decision".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_consideration',
+    category: 'clarity',
+    pattern: /\bgive\s+consideration\s+to\b/i,
+    suggestion: 'consider',
+    reason: 'Use "consider" instead of "give consideration to".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_improvement',
+    category: 'clarity',
+    pattern: /\bmake\s+an?\s+improvement\b/i,
+    suggestion: 'improve',
+    reason: 'Use "improve" instead of "make an improvement".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_assistance',
+    category: 'clarity',
+    pattern: /\bprovide\s+assistance\b/i,
+    suggestion: 'assist',
+    reason: 'Use "assist" or "help" instead of "provide assistance".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_investigation',
+    category: 'clarity',
+    pattern: /\bconduct\s+an?\s+investigation\b/i,
+    suggestion: 'investigate',
+    reason: 'Use "investigate" instead of "conduct an investigation".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_analysis',
+    category: 'clarity',
+    pattern: /\bperform\s+an?\s+analysis\b/i,
+    suggestion: 'analyze',
+    reason: 'Use "analyze" instead of "perform an analysis".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_discussion',
+    category: 'clarity',
+    pattern: /\bhave\s+a\s+discussion\b/i,
+    suggestion: 'discuss',
+    reason: 'Use "discuss" instead of "have a discussion".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_recommendation',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+recommendation\b/i,
+    suggestion: 'recommend',
+    reason: 'Use "recommend" instead of "make a recommendation".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_indication',
+    category: 'clarity',
+    pattern: /\bgive\s+an?\s+indication\b/i,
+    suggestion: 'indicate',
+    reason: 'Use "indicate" instead of "give an indication".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_explanation',
+    category: 'clarity',
+    pattern: /\bprovide\s+an?\s+explanation\b/i,
+    suggestion: 'explain',
+    reason: 'Use "explain" instead of "provide an explanation".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_determination',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+determination\b/i,
+    suggestion: 'determine',
+    reason: 'Use "determine" instead of "make a determination".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_presentation',
+    category: 'clarity',
+    pattern: /\bgive\s+a\s+presentation\b/i,
+    suggestion: 'present',
+    reason: 'Use "present" instead of "give a presentation".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_measurement',
+    category: 'clarity',
+    pattern: /\btake\s+a\s+measurement\b/i,
+    suggestion: 'measure',
+    reason: 'Use "measure" instead of "take a measurement".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_commitment',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+commitment\b/i,
+    suggestion: 'commit',
+    reason: 'Use "commit" instead of "make a commitment".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_adjustment',
+    category: 'clarity',
+    pattern: /\bmake\s+an?\s+adjustment\b/i,
+    suggestion: 'adjust',
+    reason: 'Use "adjust" instead of "make an adjustment".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_observation',
+    category: 'clarity',
+    pattern: /\bmake\s+an?\s+observation\b/i,
+    suggestion: 'observe',
+    reason: 'Use "observe" instead of "make an observation".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_contribution',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+contribution\b/i,
+    suggestion: 'contribute',
+    reason: 'Use "contribute" instead of "make a contribution".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_selection',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+selection\b/i,
+    suggestion: 'select',
+    reason: 'Use "select" or "choose" instead of "make a selection".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_comparison',
+    category: 'clarity',
+    pattern: /\bmake\s+a\s+comparison\b/i,
+    suggestion: 'compare',
+    reason: 'Use "compare" instead of "make a comparison".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_assessment',
+    category: 'clarity',
+    pattern: /\bconduct\s+an?\s+assessment\b/i,
+    suggestion: 'assess',
+    reason: 'Use "assess" instead of "conduct an assessment".',
+  }),
+  createRegexRule({
+    id: 'ST_NOM_review',
+    category: 'clarity',
+    pattern: /\bconduct\s+a\s+review\b/i,
+    suggestion: 'review',
+    reason: 'Use "review" instead of "conduct a review".',
+  }),
+
+  // ═══ Business Clichés (ST_006) ═══
+  createRegexRule({
+    id: 'ST_CLI_think_box',
+    category: 'style',
+    pattern: /\bthink\s+outside\s+the\s+box\b/i,
+    suggestion: 'be creative',
+    reason: '"Think outside the box" is an overused cliché. Try "be creative" or "innovate".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_low_hanging',
+    category: 'style',
+    pattern: /\blow[\s-]+hanging\s+fruit\b/i,
+    suggestion: 'easy wins',
+    reason: '"Low-hanging fruit" is an overused cliché. Try "easy wins" or "quick opportunities".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_move_needle',
+    category: 'style',
+    pattern: /\bmove\s+the\s+needle\b/i,
+    suggestion: 'make an impact',
+    reason: '"Move the needle" is an overused cliché. Try "make an impact" or "show progress".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_paradigm',
+    category: 'style',
+    pattern: /\bparadigm\s+shift\b/i,
+    suggestion: 'fundamental change',
+    reason: '"Paradigm shift" is overused. Try "fundamental change" or "transformation".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_next_level',
+    category: 'style',
+    pattern: /\btake\s+it\s+to\s+the\s+next\s+level\b/i,
+    suggestion: 'improve significantly',
+    reason: '"Take it to the next level" is a cliché. Be specific about the improvement.',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_game_changer',
+    category: 'style',
+    pattern: /\bgame[\s-]+changer\b/i,
+    suggestion: 'breakthrough',
+    reason: '"Game-changer" is overused. Try "breakthrough" or "transformative development".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_deep_dive',
+    category: 'style',
+    pattern: /\bdeep\s+dive\b/i,
+    suggestion: 'thorough analysis',
+    reason: '"Deep dive" is an overused cliché. Try "thorough analysis" or "detailed examination".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_circle_back',
+    category: 'style',
+    pattern: /\bcircle\s+back\b/i,
+    suggestion: 'revisit',
+    reason: '"Circle back" is business jargon. Try "revisit" or "return to".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_touch_base',
+    category: 'style',
+    pattern: /\btouch\s+base\b/i,
+    suggestion: 'connect',
+    reason: '"Touch base" is business jargon. Try "connect" or "check in".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_same_page',
+    category: 'style',
+    pattern: /\bon\s+the\s+same\s+page\b/i,
+    suggestion: 'in agreement',
+    reason: '"On the same page" is a cliché. Try "in agreement" or "aligned".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_push_envelope',
+    category: 'style',
+    pattern: /\bpush\s+the\s+envelope\b/i,
+    suggestion: 'push boundaries',
+    reason: '"Push the envelope" is a cliché. Try "push boundaries" or "innovate".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_going_forward',
+    category: 'style',
+    pattern: /\bgoing\s+forward\b/i,
+    suggestion: 'from now on',
+    reason: '"Going forward" is overused. Try "from now on", "in the future", or simply delete it.',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_leverage_verb',
+    category: 'style',
+    pattern: /\bleverage\s+(the|our|your|this|that|these|those|existing|current)\b/i,
+    suggestion: (m) => `use ${m[1]}`,
+    reason: '"Leverage" as a verb is business jargon. Try "use", "employ", or "take advantage of".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_drill_down',
+    category: 'style',
+    pattern: /\bdrill\s+down\b/i,
+    suggestion: 'examine closely',
+    reason: '"Drill down" is business jargon. Try "examine closely" or "analyze in detail".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_bandwidth',
+    category: 'style',
+    pattern:
+      /\b(have|has|had|no|enough|more)\s+bandwidth\b(?!\s*(of|to\s+handle\s+data|to\s+transfer|speed|Mbps|Gbps|rate))/i,
+    suggestion: (m) => `${m[1]} capacity`,
+    reason:
+      'Using "bandwidth" for personal capacity is jargon. Try "capacity", "time", or "resources".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_value_add',
+    category: 'style',
+    pattern: /\bvalue[\s-]+add\b/i,
+    suggestion: 'benefit',
+    reason: '"Value-add" is business jargon. Try "benefit" or "advantage".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_end_of_day',
+    category: 'style',
+    pattern: /\bat\s+the\s+end\s+of\s+the\s+day\b/i,
+    suggestion: 'ultimately',
+    reason: '"At the end of the day" is a cliché. Try "ultimately" or "in conclusion".',
+  }),
+  createRegexRule({
+    id: 'ST_CLI_actionable',
+    category: 'style',
+    pattern:
+      /\bactionable\s+(insights?|items?|steps?|takeaways?|recommendations?|feedback|data|intelligence|information|strategies?)\b/i,
+    suggestion: (m) => `practical ${m[1]}`,
+    reason: '"Actionable" is overused business jargon. Try "practical" or "useful".',
+  }),
+
+  // ═══ Inflated / Filler Phrases (ST_002 + ST_004) ═══
+  createRegexRule({
+    id: 'ST_INF_goes_without',
+    category: 'clarity',
+    pattern: /\bit\s+goes\s+without\s+saying\b/i,
+    suggestion: '',
+    reason: "If it goes without saying, don't say it! Remove this filler.",
+  }),
+  createRegexRule({
+    id: 'ST_INF_needless',
+    category: 'clarity',
+    pattern: /\bneedless\s+to\s+say\b/i,
+    suggestion: '',
+    reason: "If it's needless to say, just say it directly. Remove this filler.",
+  }),
+  createRegexRule({
+    id: 'ST_INF_worth_noting',
+    category: 'clarity',
+    pattern: /\bit\s+is\s+worth\s+noting\s+that\b/i,
+    suggestion: '',
+    reason: '"It is worth noting that" is filler. State the point directly.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_matter_fact',
+    category: 'clarity',
+    pattern: /\bas\s+a\s+matter\s+of\s+fact\b/i,
+    suggestion: 'in fact',
+    reason: '"As a matter of fact" is wordy. Use "in fact" or "actually".',
+  }),
+  createRegexRule({
+    id: 'ST_INF_final_analysis',
+    category: 'clarity',
+    pattern: /\bin\s+the\s+final\s+analysis\b/i,
+    suggestion: 'finally',
+    reason: '"In the final analysis" is wordy. Use "finally" or "ultimately".',
+  }),
+  createRegexRule({
+    id: 'ST_INF_point_fact',
+    category: 'clarity',
+    pattern: /\bas\s+a\s+point\s+of\s+fact\b/i,
+    suggestion: 'in fact',
+    reason: '"As a point of fact" is wordy. Use "in fact".',
+  }),
+  createRegexRule({
+    id: 'ST_INF_close_proximity',
+    category: 'clarity',
+    pattern: /\bclose\s+proximity\b/i,
+    suggestion: 'near',
+    reason: '"Close proximity" is redundant. "Proximity" already means nearness. Use "near".',
+  }),
+  createRegexRule({
+    id: 'ST_INF_future_plans',
+    category: 'clarity',
+    pattern: /\bfuture\s+plans\b/i,
+    suggestion: 'plans',
+    reason: '"Future plans" is redundant — all plans are for the future.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_past_history',
+    category: 'clarity',
+    pattern: /\bpast\s+history\b/i,
+    suggestion: 'history',
+    reason: '"Past history" is redundant — history is always in the past.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_new_innovation',
+    category: 'clarity',
+    pattern: /\bnew\s+innovation\b/i,
+    suggestion: 'innovation',
+    reason: '"New innovation" is redundant — innovations are inherently new.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_unexpected_surprise',
+    category: 'clarity',
+    pattern: /\bunexpected\s+surprise\b/i,
+    suggestion: 'surprise',
+    reason: '"Unexpected surprise" is redundant — surprises are unexpected by definition.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_free_gift',
+    category: 'clarity',
+    pattern: /\bfree\s+gift\b/i,
+    suggestion: 'gift',
+    reason: '"Free gift" is redundant — a gift is free by definition.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_advance_warning',
+    category: 'clarity',
+    pattern: /\badvance\s+warning\b/i,
+    suggestion: 'warning',
+    reason: '"Advance warning" is redundant — a warning is given in advance.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_added_bonus',
+    category: 'clarity',
+    pattern: /\badded\s+bonus\b/i,
+    suggestion: 'bonus',
+    reason: '"Added bonus" is redundant — a bonus is an addition.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_completely_eliminate',
+    category: 'clarity',
+    pattern: /\bcompletely\s+eliminate\b/i,
+    suggestion: 'eliminate',
+    reason: '"Completely eliminate" is redundant — elimination is total by nature.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_final_outcome',
+    category: 'clarity',
+    pattern: /\bfinal\s+outcome\b/i,
+    suggestion: 'outcome',
+    reason: '"Final outcome" is redundant.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_joint_collaboration',
+    category: 'clarity',
+    pattern: /\bjoint\s+collaboration\b/i,
+    suggestion: 'collaboration',
+    reason: '"Joint collaboration" is redundant — collaboration already implies working together.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_past_experience',
+    category: 'clarity',
+    pattern: /\bpast\s+experience\b/i,
+    suggestion: 'experience',
+    reason: '"Past experience" is redundant — experience is always from the past.',
+  }),
+  createRegexRule({
+    id: 'ST_INF_brief_summary',
+    category: 'clarity',
+    pattern: /\bbrief\s+summary\b/i,
+    suggestion: 'summary',
+    reason: '"Brief summary" is redundant — summaries are inherently brief.',
+  }),
+];

package/src/rules/categories/style.ts

@@ -0,0 +1,78 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+export const styleRules: Rule[] = [
+  // Passive Voice via Regex (legacy)
+  createRegexRule({
+    id: 'passive-voice-ed',
+    category: 'style',
+    pattern: /\b(am|are|is|was|were|be|been|being)\s+(\w+ed)\b/i,
+    suggestion: 'Consider using active voice',
+    reason: 'Passive voice can make sentences weaker and less direct.',
+  }),
+  createRegexRule({
+    id: 'passive-voice-en',
+    category: 'style',
+    pattern: /\b(am|are|is|was|were|be|been|being)\s+(\w+en)\b/i,
+    suggestion: 'Consider using active voice',
+    reason: 'Passive voice can make sentences weaker and less direct.',
+  }),
+
+  // NEW NLP Rule: Detect consecutive nouns (Noun String) which are hard to read
+  {
+    id: 'noun-string',
+    type: 'nlp',
+    category: 'clarity',
+    reason: 'Long strings of nouns reduce clarity. Try using prepositions to separate them.',
+    suggestion: 'Consider rephrasing',
+    check: (text: string, doc: any): Issue[] => {
+      const issues: Issue[] = [];
+      const matches = doc.match('#Noun #Noun #Noun #Noun+');
+      matches.forEach((m: any) => {
+        const str = m.text();
+        const offset = text.indexOf(str);
+        if (offset !== -1) {
+          issues.push({
+            id: `noun-string-${offset}`,
+            type: 'clarity',
+            original: str,
+            suggestion: 'Consider rephrasing',
+            reason: 'Long strings of nouns are hard to read.',
+            offset,
+            length: str.length,
+          });
+        }
+      });
+      return issues;
+    },
+  },
+
+  // NEW NLP Rule: Avoid starting sentences with coordinating conjunctions heavily
+  {
+    id: 'conjunction-start',
+    type: 'nlp',
+    category: 'style',
+    reason: 'Starting a sentence with "And" or "But" can make writing less formal.',
+    suggestion: 'Consider merging sentences or removing',
+    check: (text: string, doc: any): Issue[] => {
+      const issues: Issue[] = [];
+      const matches = doc.match('^#Conjunction');
+      matches.forEach((m: any) => {
+        const str = m.text();
+        const offset = text.indexOf(str);
+        if (offset !== -1 && (str.toLowerCase() === 'and ' || str.toLowerCase() === 'but ')) {
+          issues.push({
+            id: `conjunction-start-${offset}`,
+            type: 'style',
+            original: str.trim(),
+            suggestion: 'Additionally, / However,',
+            reason: 'Starting sentences with coordinating conjunctions is informal.',
+            offset,
+            length: str.trim().length,
+          });
+        }
+      });
+      return issues;
+    },
+  },
+];