opengrammar-server 2.0.644277

package/src/nlp/nlp-engine.ts

@@ -0,0 +1,17 @@
+import nlp from 'compromise';
+
+/**
+ * Parses the text into an NLP document to analyze parts of speech, syntax, and sentence structure.
+ */
+export function parseNLP(text: string) {
+  return nlp(text);
+}
+
+/**
+ * Helper to find specific parts of speech patterns in the parsed text.
+ * Uses compromise's match syntax (e.g., '#Verb #Adjective')
+ */
+export function findNLPPattern(text: string, pattern: string) {
+  const doc = parseNLP(text);
+  return doc.match(pattern);
+}

package/src/nlp/tone-analyzer.ts

@@ -0,0 +1,269 @@
+import type { WritingContext } from '../rules/context-filter.js';
+
+/**
+ * ════════════════════════════════════════════════════════
+ *  Tone Analyzer — ToneAnalyzer
+ *  Detects the emotional/professional tone of text.
+ *  Rule-based Tier 1 (free, instant, no API).
+ * ════════════════════════════════════════════════════════
+ */
+
+export interface ToneSignal {
+  type: 'hedging' | 'passive_aggression' | 'apology_filler' | 'negativity' | 'formality_mismatch' | 'confidence_killer' | 'aggressive' | 'positive';
+  phrase: string;
+  offset: number;
+  suggestion: string;
+  severity: 'info' | 'warning' | 'error';
+}
+
+export interface ToneResult {
+  dominant: 'assertive' | 'uncertain' | 'formal' | 'informal' | 'negative' | 'aggressive' | 'friendly' | 'neutral';
+  score: number;        // 0–100: 100 = very confident/clear
+  signals: ToneSignal[];
+  tips: string[];
+}
+
+// ─── Hedging words/phrases ───
+const HEDGING_WORDS = [
+  'maybe', 'perhaps', 'possibly', 'probably', 'apparently',
+  'i think', 'i guess', 'i suppose', 'i believe', 'i feel like',
+  'sort of', 'kind of', 'somewhat', 'rather', 'fairly',
+  'might', 'could', 'may', 'seem', 'seems', 'seemed', 'appears',
+  'it seems', 'it appears', 'it looks like',
+  'if i understand correctly', 'correct me if i\'m wrong',
+  'roughly', 'approximately', 'more or less', 'in a way', 'as it were',
+];
+
+// ─── Passive-aggressive phrases ───
+const PASSIVE_AGGRESSION_PATTERNS = [
+  /\bas (I|we) (said|mentioned|noted|indicated|pointed out|explained|stated)\b/i,
+  /\bper my (last|previous|earlier|recent|prior)\b/i,
+  /\bas per\b/i,
+  /\bgoing forward\b/i,
+  /\bnot sure if you (saw|noticed|read|received)\b/i,
+  /\bjust (a (gentle|friendly|quick|small) )?(reminder|heads?[ -]?up|note|fyi)\b/i,
+  /\bfriendly reminder\b/i,
+  /\bhoping you (can|could|will|would|might)\b/i,
+  /\bplease (do|kindly) advise\b/i,
+];
+
+// ─── Apology fillers (weakening phrases) ───
+const APOLOGY_FILLER_PATTERNS = [
+  /\bjust (wanted|checking|following|wondering|hoping|reaching)\b/i,
+  /\bsorry (to (bother|bug|trouble|disturb)|for (the (inconvenience|trouble|delay|confusion)))\b/i,
+  /\bif that'?s? (okay|alright|fine|good|acceptable|convenient)\b/i,
+  /\bif (you) (don'?t|do) mind\b/i,
+  /\bdoes that make sense\b/i,
+  /\bif that makes sense\b/i,
+  /\bam I making sense\b/i,
+  /\bhope this (helps|is helpful|is okay|is fine|finds you well)\b/i,
+  /\bjust (a|an) (idea|thought|suggestion|question)\b/i,
+  /\bfeel free to\b/i,
+  /\bwhenever you get a chance\b/i,
+  /\bno rush (but|however|though|,)\b/i,
+];
+
+// ─── Confidence killers ───
+const CONFIDENCE_KILLER_PATTERNS = [
+  /\bhopefully\b/i,
+  /\bthis (probably|might|may|could) (not )?(work|help|be|make)\b/i,
+  /\bi (might be|could be|may be) wrong\b/i,
+  /\bnot sure if\b/i,
+  /\bnot 100% sure\b/i,
+  /\bi'?m no expert\b/i,
+  /\btake it (with a grain of salt|or leave it)\b/i,
+  /\bdon'?t quote me\b/i,
+  /\byou (may|might|could|can) disagree\b/i,
+];
+
+// ─── Informal/slang (flagged in formal contexts) ───
+const INFORMAL_PATTERNS = [
+  /\bgonna\b/i, /\bwanna\b/i, /\bgotta\b/i, /\bkinda\b/i, /\bsorta\b/i,
+  /\byeah\b/i, /\bnope\b/i, /\byep\b/i, /\bbtw\b/i, /\bfyi\b/i,
+  /\blol\b/i, /\bomg\b/i, /\bwtf\b/i, /\bidk\b/i, /\bimo\b/i,
+  /\bidk\b/i, /\bimo\b/i, /\btbh\b/i, /\bngl\b/i, /\biykyk\b/i,
+  /\bCHERRS?\b/i, /\bcheers\b/i,
+];
+
+// ─── Aggressive phrases ───
+const AGGRESSIVE_PATTERNS = [
+  /\byou (always|never|constantly|consistently|repeatedly) (fail|forget|ignore|miss|avoid|dismiss|neglect)\b/i,
+  /\bthis is (unacceptable|ridiculous|absurd|outrageous|disgusting)\b/i,
+  /\bI demand\b/i,
+  /\byou (must|have to|need to) (immediately|now|right now|at once)\b/i,
+  /\bwhy (haven'?t|hasn'?t|didn'?t|don'?t|won'?t) you\b/i,
+  /\bI'?m (not happy|very (unhappy|upset|disappointed|frustrated|angry))\b/i,
+];
+
+function findInText(text: string, pattern: RegExp): { phrase: string; offset: number } | null {
+  const match = text.match(pattern);
+  if (!match || match.index === undefined) return null;
+  return { phrase: match[0], offset: match.index };
+}
+
+function countMatches(text: string, patterns: RegExp[]): number {
+  return patterns.filter((p) => p.test(text)).length;
+}
+
+function checkHedging(lowerText: string, signals: ToneSignal[], tips: string[]): number {
+  const hedgeCount = HEDGING_WORDS.filter((w) => lowerText.includes(w)).length;
+  if (hedgeCount >= 2) {
+    const firstHedge = HEDGING_WORDS.find((w) => lowerText.includes(w)) || '';
+    const offset = lowerText.indexOf(firstHedge);
+    signals.push({
+      type: 'hedging',
+      phrase: firstHedge,
+      offset,
+      suggestion: `Replace hedging language with direct statements. Instead of "${firstHedge}", use assertive phrasing.`,
+      severity: hedgeCount >= 4 ? 'warning' : 'info',
+    });
+    tips.push(`Your text contains ${hedgeCount} hedging expressions. Try replacing "I think/maybe/perhaps" with direct statements for a more confident tone.`);
+  }
+  return hedgeCount;
+}
+
+function checkPatterns(
+  text: string,
+  patterns: RegExp[],
+  type: ToneSignal['type'],
+  severity: ToneSignal['severity'],
+  suggestionFn: (phrase: string) => string,
+  tipMsg?: string
+): number {
+  let count = 0;
+  let firstFound: { phrase: string; offset: number } | null = null;
+  for (const pattern of patterns) {
+    if (pattern.test(text)) {
+      count++;
+      if (!firstFound) {
+        firstFound = findInText(text, pattern);
+      }
+    }
+  }
+  return count;
+}
+
+function processSignals(
+  text: string,
+  patterns: RegExp[],
+  type: ToneSignal['type'],
+  severity: ToneSignal['severity'],
+  suggestionFn: (phrase: string) => string,
+  signals: ToneSignal[],
+  tips: string[],
+  tipMsg?: string
+): number {
+  const count = countMatches(text, patterns);
+  if (count >= 1) {
+    const found = patterns.map((p) => findInText(text, p)).find(Boolean);
+    if (found) {
+      signals.push({
+        type,
+        phrase: found.phrase,
+        offset: found.offset,
+        suggestion: suggestionFn(found.phrase),
+        severity,
+      });
+      if (tipMsg) tips.push(tipMsg);
+    }
+  }
+  return count;
+}
+
+/**
+ * Analyze the tone of text based on rule signals.
+ * Returns a ToneResult with detected signals and recommendations.
+ */
+export function analyzeTone(text: string, context?: WritingContext): ToneResult {
+  const lowerText = text.toLowerCase();
+  const signals: ToneSignal[] = [];
+  const tips: string[] = [];
+
+  const hedgeCount = checkHedging(lowerText, signals, tips);
+
+  processSignals(
+    text, PASSIVE_AGGRESSION_PATTERNS, 'passive_aggression', 'warning',
+    (phrase) => `"${phrase}" can sound passive-aggressive. Consider a more direct alternative.`,
+    signals, tips,
+    'Avoid phrases that may sound passive-aggressive (e.g., "as I mentioned", "per my last email"). Be direct instead.'
+  );
+
+  processSignals(
+    text, APOLOGY_FILLER_PATTERNS, 'apology_filler', 'info',
+    (phrase) => `Remove "${phrase}" — it weakens your message unnecessarily.`,
+    signals, tips,
+    'Apology fillers like "just wanted to" or "if that\'s okay" undermine your confidence. Remove them for a stronger message.'
+  );
+
+  processSignals(
+    text, CONFIDENCE_KILLER_PATTERNS, 'confidence_killer', 'info',
+    (phrase) => `"${phrase}" undermines your authority. State your point directly.`,
+    signals, tips
+  );
+
+  const negatives = (text.match(/\b(can'?t|won'?t|never|not|don'?t|doesn'?t|didn'?t|couldn'?t|wouldn'?t|shouldn'?t|haven'?t|hasn'?t|hadn'?t|no\s+one|nobody|nothing|nowhere|neither|nor)\b/gi) || []).length;
+  if (negatives >= 4) {
+    signals.push({
+      type: 'negativity',
+      phrase: `${negatives} negative expressions`,
+      offset: 0,
+      suggestion: 'Consider reframing some negative statements as positive alternatives.',
+      severity: negatives >= 7 ? 'warning' : 'info',
+    });
+    tips.push(`Your text has ${negatives} negative expressions. Reframing some as positive creates a more constructive tone.`);
+  }
+
+  if (context === 'email' || context === 'document' || !context) {
+    processSignals(
+      text, INFORMAL_PATTERNS, 'formality_mismatch', 'warning',
+      (phrase) => `"${phrase}" is too informal for formal writing. Use more formal language.`,
+      signals, tips,
+      'Informal words or abbreviations detected. Consider using formal language in this context.'
+    );
+  }
+
+  const aggressiveCount = processSignals(
+    text, AGGRESSIVE_PATTERNS, 'aggressive', 'error',
+    (phrase) => `"${phrase}" sounds aggressive. Try a more constructive phrasing.`,
+    signals, tips,
+    'Your text may sound aggressive. Focus on the issue, not the person, and use collaborative language.'
+  );
+
+  const dominant = determineDominantTone(signals, hedgeCount, negatives, aggressiveCount);
+  const score = computeScore(signals, hedgeCount, negatives, aggressiveCount);
+
+  return { dominant, score, signals, tips };
+}
+
+function determineDominantTone(
+  signals: ToneSignal[],
+  hedgeCount: number,
+  negatives: number,
+  aggressiveCount: number,
+): ToneResult['dominant'] {
+  if (aggressiveCount >= 2) return 'aggressive';
+  if (signals.some((s) => s.type === 'aggressive')) return 'aggressive';
+  if (negatives >= 7) return 'negative';
+  if (hedgeCount >= 4) return 'uncertain';
+  if (signals.some((s) => s.type === 'formality_mismatch')) return 'informal';
+  if (signals.some((s) => s.type === 'passive_aggression')) return 'aggressive';
+  if (hedgeCount >= 2 || signals.some((s) => s.type === 'confidence_killer')) return 'uncertain';
+  if (signals.length === 0) return 'assertive';
+  return 'neutral';
+}
+
+function computeScore(
+  signals: ToneSignal[],
+  hedgeCount: number,
+  negatives: number,
+  aggressiveCount: number,
+): number {
+  let score = 100;
+  score -= hedgeCount * 8;       // each hedge word -8 pts
+  score -= negatives * 3;        // each negative -3 pts
+  score -= aggressiveCount * 15; // aggressive is bad -15 pts
+  score -= signals.filter((s) => s.severity === 'warning').length * 10;
+  score -= signals.filter((s) => s.severity === 'error').length * 20;
+  score -= signals.filter((s) => s.severity === 'info').length * 5;
+  return Math.max(0, Math.min(100, score));
+}

package/src/rephraser.ts

@@ -0,0 +1,146 @@
+import { Groq } from 'groq-sdk';
+import OpenAI from 'openai';
+import type { LLMProvider } from './shared-types.js';
+
+export type RephraseGoal = 'clarity' | 'formal' | 'concise' | 'friendly';
+
+export interface RephraseSuggestion {
+  text: string;
+  label: string;
+}
+
+export interface RephraseResult {
+  suggestions: RephraseSuggestion[];
+  explanation: string;
+  bestMatch: number;
+}
+
+const GOAL_DESCRIPTIONS: Record<RephraseGoal, { adjective: string; label: string }> = {
+  clarity:  { adjective: 'clearer and easier to understand',                label: '🎯 Clearer'   },
+  formal:   { adjective: 'more formal and professional',                     label: '👔 Formal'    },
+  concise:  { adjective: 'shorter and more concise (remove filler words)',   label: '✂️ Concise'  },
+  friendly: { adjective: 'warmer, friendlier, and more approachable',        label: '😊 Friendly'  },
+};
+
+const SYSTEM_PROMPT = `You are an expert writing assistant. Rewrite the given sentence in exactly 3 different ways.
+
+Rules:
+1. Keep the core meaning intact
+2. Apply the requested goal (clarity/formal/concise/friendly)  
+3. Each rewrite must be meaningfully different from the others
+4. Keep the same approximate length unless goal is "concise"
+5. Return ONLY a JSON object — no preamble, no markdown
+
+Format:
+{
+  "suggestions": [
+    { "text": "First rewrite", "label": "Option 1" },
+    { "text": "Second rewrite", "label": "Option 2" },
+    { "text": "Third rewrite", "label": "Option 3" }
+  ],
+  "explanation": "One sentence explaining what was improved",
+  "bestMatch": 0
+}`;
+
+export class Rephraser {
+  /**
+   * Generate 3 rephrase suggestions for a given sentence.
+   * Supports Groq (free), OpenAI, Ollama, and OpenRouter.
+   */
+  static async rephrase(
+    sentence: string,
+    goal: RephraseGoal = 'clarity',
+    apiKey: string,
+    provider: LLMProvider = 'groq',
+    model?: string,
+    baseUrl?: string,
+  ): Promise<RephraseResult> {
+    const goalDesc = GOAL_DESCRIPTIONS[goal];
+    const userPrompt = `Rewrite this sentence in 3 ways that are ${goalDesc.adjective}:\n\n"${sentence}"`;
+
+    try {
+      if (provider === 'groq') {
+        return await Rephraser.rephraseWithGroq(userPrompt, apiKey, model || 'llama3-8b-8192');
+      } else {
+        return await Rephraser.rephraseWithOpenAI(userPrompt, apiKey, model || 'gpt-3.5-turbo', provider, baseUrl);
+      }
+    } catch (err) {
+      console.error(`[Rephraser] ${provider} error:`, err);
+      // Return empty gracefully
+      return {
+        suggestions: [],
+        explanation: 'Rephrase failed. Please check your API key and try again.',
+        bestMatch: 0,
+      };
+    }
+  }
+
+  private static async rephraseWithGroq(
+    userPrompt: string,
+    apiKey: string,
+    model: string,
+  ): Promise<RephraseResult> {
+    const groq = new Groq({ apiKey });
+    const res = await groq.chat.completions.create({
+      model,
+      messages: [
+        { role: 'system', content: SYSTEM_PROMPT },
+        { role: 'user',   content: userPrompt },
+      ],
+      response_format: { type: 'json_object' },
+      temperature: 0.7,
+      max_tokens: 512,
+    });
+    const raw = res.choices[0]?.message?.content || '{}';
+    return Rephraser.parseResult(raw);
+  }
+
+  private static async rephraseWithOpenAI(
+    userPrompt: string,
+    apiKey: string,
+    model: string,
+    provider: LLMProvider,
+    baseUrl?: string,
+  ): Promise<RephraseResult> {
+    const providerUrls: Record<string, string> = {
+      openai:      'https://api.openai.com/v1',
+      openrouter:  'https://openrouter.ai/api/v1',
+      together:    'https://api.together.xyz/v1',
+      ollama:      'http://localhost:11434/v1',
+      custom:      baseUrl || '',
+    };
+    const openai = new OpenAI({
+      apiKey: apiKey || 'ollama',
+      baseURL: baseUrl || providerUrls[provider as string] || providerUrls.openai,
+    });
+    const res = await openai.chat.completions.create({
+      model,
+      messages: [
+        { role: 'system', content: SYSTEM_PROMPT },
+        { role: 'user',   content: userPrompt },
+      ],
+      response_format: { type: 'json_object' },
+      temperature: 0.7,
+      max_tokens: 512,
+    });
+    const raw = res.choices[0]?.message?.content || '{}';
+    return Rephraser.parseResult(raw);
+  }
+
+  private static parseResult(raw: string): RephraseResult {
+    try {
+      const cleaned = raw.replace(/^```json\s*/, '').replace(/\s*```$/, '');
+      const parsed = JSON.parse(cleaned);
+      return {
+        suggestions: (parsed.suggestions || []).map((s: any) => ({
+          text: s.text || s,
+          label: s.label || 'Option',
+        })),
+        explanation: parsed.explanation || '',
+        bestMatch:   typeof parsed.bestMatch === 'number' ? parsed.bestMatch : 0,
+      };
+    } catch {
+      return { suggestions: [], explanation: 'Could not parse response.', bestMatch: 0 };
+    }
+  }
+}

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

@@ -0,0 +1,182 @@
+import type { Issue } from '../../shared-types.js';
+import { createRegexRule, type Rule } from '../types.js';
+
+/**
+ * ═══════════════════════════════════════════════════
+ *  Academic & Scholarly Writing (AW)
+ *  Weasel words, vague quantifiers, formality issues
+ * ═══════════════════════════════════════════════════
+ */
+export const academicWritingRules: Rule[] = [
+  // ═══ First Person in Academic (AW_001) ═══
+  createRegexRule({
+    id: 'AW_I_think',
+    category: 'style',
+    pattern: /\bI\s+think\s+that\b/i,
+    suggestion: 'Evidence suggests that',
+    reason: 'Avoid "I think" in academic writing. Use evidence-based language instead.',
+  }),
+  createRegexRule({
+    id: 'AW_I_believe',
+    category: 'style',
+    pattern: /\bI\s+believe\s+that\b/i,
+    suggestion: 'It can be argued that',
+    reason: 'Avoid "I believe" in academic writing. Use objective phrasing.',
+  }),
+  createRegexRule({
+    id: 'AW_I_feel',
+    category: 'style',
+    pattern: /\bI\s+feel\s+that\b/i,
+    suggestion: 'The evidence indicates that',
+    reason: 'Avoid "I feel" in academic writing. Support claims with evidence.',
+  }),
+  createRegexRule({
+    id: 'AW_in_my_opinion',
+    category: 'style',
+    pattern: /\bin\s+my\s+opinion\b/i,
+    suggestion: 'arguably',
+    reason: '"In my opinion" is subjective. Use "arguably" or cite evidence.',
+  }),
+  createRegexRule({
+    id: 'AW_I_personally',
+    category: 'style',
+    pattern: /\bI\s+personally\b/i,
+    suggestion: '(remove or rephrase)',
+    reason: '"I personally" is redundant and too subjective for academic writing.',
+  }),
+  createRegexRule({
+    id: 'AW_obviously',
+    category: 'style',
+    pattern:
+      /\b(obviously|clearly|of\s+course|needless\s+to\s+say|it\s+is\s+obvious\s+that|everyone\s+knows)\b/i,
+    suggestion: '(remove)',
+    reason:
+      "If something is truly obvious, it doesn't need to be stated. These phrases can alienate readers who don't find it obvious.",
+  }),
+
+  // ═══ Weasel Words (AW_004) ═══
+  createRegexRule({
+    id: 'AW_some_people',
+    category: 'style',
+    pattern: /\bsome\s+people\s+(say|believe|think|argue|claim|suggest|feel)\b/i,
+    suggestion: '[Cite specific source]',
+    reason: '"Some people say" is vague. Cite specific sources or studies.',
+  }),
+  createRegexRule({
+    id: 'AW_studies_show',
+    category: 'style',
+    pattern:
+      /\bstudies\s+(show|suggest|indicate|have\s+shown|have\s+found|demonstrate|reveal|confirm)\b/i,
+    suggestion: '[Author (Year)] found that',
+    reason: '"Studies show" is vague. Cite the specific studies (Author, Year).',
+  }),
+  createRegexRule({
+    id: 'AW_experts_say',
+    category: 'style',
+    pattern:
+      /\b(experts|researchers|scientists|scholars|critics|analysts)\s+(say|believe|argue|claim|suggest|agree|think|note|point\s+out)\b/i,
+    suggestion: '[Named experts] argue that',
+    reason: 'Name the specific experts and cite their work.',
+  }),
+  createRegexRule({
+    id: 'AW_it_is_believed',
+    category: 'style',
+    pattern:
+      /\bit\s+is\s+(widely\s+)?(believed|known|accepted|understood|recognized|acknowledged|thought|assumed|considered)\b/i,
+    suggestion: '[Citation needed]',
+    reason: 'Who believes/knows this? Provide a citation for the claim.',
+  }),
+  createRegexRule({
+    id: 'AW_many_argue',
+    category: 'style',
+    pattern:
+      /\b(many|several|numerous|various|certain)\s+(people|scholars|researchers|experts|critics|authors|studies)\s+(have\s+)?(argued|suggested|claimed|shown|demonstrated|noted|found|stated|asserted)\b/i,
+    suggestion: '[Specific citation needed]',
+    reason: 'Quantify or cite specific sources instead of vague attribution.',
+  }),
+  createRegexRule({
+    id: 'AW_recently',
+    category: 'style',
+    pattern: /\brecently\b/i,
+    suggestion: 'In [specific year/period]',
+    reason: '"Recently" is vague in academic writing. Specify the time period.',
+  }),
+
+  // ═══ Informal Transitions (AW_006) ═══
+  createRegexRule({
+    id: 'AW_plus_start',
+    category: 'style',
+    pattern: /(?:^|[.!?]\s+)Plus\s+/g,
+    suggestion: 'Additionally, ',
+    reason:
+      '"Plus" at the start of a sentence is informal. Use "Additionally", "Moreover", or "Furthermore".',
+  }),
+  createRegexRule({
+    id: 'AW_also_start',
+    category: 'style',
+    pattern: /(?:^|[.!?]\s+)Also\s*,/g,
+    suggestion: 'Furthermore,',
+    reason:
+      '"Also" starting a sentence is informal. Use "Furthermore", "Moreover", or "In addition".',
+  }),
+  createRegexRule({
+    id: 'AW_so_start',
+    category: 'style',
+    pattern: /(?:^|[.!?]\s+)So\s+/g,
+    suggestion: 'Therefore, ',
+    reason: '"So" starting a sentence is informal. Use "Therefore", "Consequently", or "Thus".',
+  }),
+  createRegexRule({
+    id: 'AW_anyway_start',
+    category: 'style',
+    pattern: /(?:^|[.!?]\s+)Anyway\s*,/g,
+    suggestion: 'Nevertheless,',
+    reason: '"Anyway" is informal. Use "Nevertheless", "Regardless", or "In any case".',
+  }),
+  createRegexRule({
+    id: 'AW_well_start',
+    category: 'style',
+    pattern: /(?:^|[.!?]\s+)Well\s*,/g,
+    suggestion: '',
+    reason: '"Well" as a sentence starter is conversational filler. Remove it in academic writing.',
+  }),
+  createRegexRule({
+    id: 'AW_basically',
+    category: 'style',
+    pattern: /\bbasically\b/i,
+    suggestion: '(remove)',
+    reason: '"Basically" is filler in academic writing. State the point directly.',
+  }),
+  createRegexRule({
+    id: 'AW_actually',
+    category: 'style',
+    pattern: /\bactually\b/i,
+    suggestion: '(remove or rephrase)',
+    reason: '"Actually" is often filler. Remove it unless correcting a misconception.',
+  }),
+
+  // ═══ Hedging Excess (AW — related to ST_003) ═══
+  createRegexRule({
+    id: 'AW_sort_of',
+    category: 'style',
+    pattern:
+      /\bsort\s+of\s+(a|an|the|like|similar|different|important|interesting|difficult|easy|good|bad|big|small)\b/i,
+    suggestion: (m) => `somewhat ${m[1]}`,
+    reason: '"Sort of" is vague and informal. Use "somewhat" or be more precise.',
+  }),
+  createRegexRule({
+    id: 'AW_kind_of',
+    category: 'style',
+    pattern:
+      /\bkind\s+of\s+(a|an|the|like|similar|different|important|interesting|difficult|easy|good|bad|big|small)\b/i,
+    suggestion: (m) => `somewhat ${m[1]}`,
+    reason: '"Kind of" is vague and informal. Use "somewhat" or be more precise.',
+  }),
+  createRegexRule({
+    id: 'AW_it_could',
+    category: 'style',
+    pattern: /\bit\s+could\s+be\s+argued\s+that\b/i,
+    suggestion: 'One argument is that',
+    reason: '"It could be argued" is weak hedging. State the argument directly.',
+  }),
+];