slopfix 0.0.0-stage → 0.1.1

package/src/rules/en.js

@@ -0,0 +1,221 @@
+import { phraseRule, regexRule } from './helpers.js';
+
+// English rules. To add a phrase, add a line to the right list.
+// "phrase" only reports it, ["phrase", "replacement"] also fixes it with --fix.
+
+const lang = 'en';
+
+export default [
+  phraseRule({
+    id: 'en/chatbot-artifact',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: 'Chatbot leftover. This was clearly pasted from an assistant.',
+    phrases: [
+      'as an AI language model',
+      'as an AI model',
+      'as a large language model',
+      'my knowledge cutoff',
+      'as of my last knowledge update',
+      'as of my last update',
+      'I cannot browse the internet',
+      "I don't have access to real-time",
+      'I hope this email finds you well',
+      'I hope this message finds you well',
+      "I'd be happy to help",
+      'I would be happy to help',
+      'great question',
+      "here's a breakdown",
+      'here is a breakdown',
+      "here's a comprehensive",
+      'here is a comprehensive',
+      'regenerate response',
+    ],
+  }),
+  regexRule({
+    id: 'en/sycophantic-opener',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: 'Sycophantic chatbot opener. Removed with --fix.',
+    patterns: [/^[ \t]*(?:certainly|absolutely|of course|sure thing)![ \t]*/gimu],
+    fix: '',
+  }),
+  regexRule({
+    id: 'en/chatbot-sign-off',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: 'Chatbot sign-off. The whole sentence is removed with --fix.',
+    patterns: [
+      /(?:(?<=[.!?:])[ \t]+|^[ \t]*)(?:I hope (?:this|that) helps|let me know if you (?:have|need) (?:any|anything)|feel free to (?:reach out|ask|let me know)|don['’]t hesitate to (?:reach out|ask)|happy (?:coding|writing)!)[^.!?\n]*[.!?]*/gimu,
+    ],
+    fix: '',
+  }),
+  phraseRule({
+    id: 'en/filler-opener',
+    lang,
+    category: 'filler',
+    severity: 'warning',
+    message: 'Filler phrase. Delete it and say the thing.',
+    drop: true,
+    phrases: [
+      "it's important to note that",
+      'it is important to note that',
+      "it's worth noting that",
+      'it is worth noting that',
+      "it's worth mentioning that",
+      'it is worth mentioning that',
+      "it's important to remember that",
+      'it is important to remember that',
+      "it's crucial to understand that",
+      'it is crucial to understand that',
+      'it should be noted that',
+      'needless to say,',
+      'at the end of the day,',
+      "in today's fast-paced world,",
+      "in today's digital age,",
+      "in today's digital landscape,",
+      "in today's ever-evolving landscape,",
+      'in an ever-evolving world,',
+      'without further ado,',
+      'in conclusion,',
+      'in summary,',
+      'to sum up,',
+      'all in all,',
+    ],
+  }),
+  phraseRule({
+    id: 'en/hype-intro',
+    lang,
+    category: 'filler',
+    severity: 'warning',
+    message: 'Hype intro or outro typical of generated text.',
+    phrases: [
+      "let's dive in",
+      "let's dive into",
+      "let's dive deeper",
+      'buckle up',
+      'in the ever-evolving world of',
+      'in the ever-evolving landscape of',
+      'in the realm of',
+      'when it comes to',
+      'navigate the complexities',
+      'navigating the complexities',
+      'stands as a testament',
+      'serves as a testament',
+      'a testament to',
+      'plays a crucial role',
+      'plays a pivotal role',
+      'plays a vital role',
+      'unlock the full potential',
+      'unlock the power of',
+      'harness the power of',
+      'a game-changer',
+      'a game changer',
+      'take it to the next level',
+    ],
+  }),
+  phraseRule({
+    id: 'en/ai-vocabulary',
+    lang,
+    category: 'vocabulary',
+    severity: 'warning',
+    message: 'Word that is heavily overused by language models.',
+    phrases: [
+      ['delve into', 'dig into'],
+      ['delves into', 'digs into'],
+      ['delving into', 'digging into'],
+      ['delved into', 'dug into'],
+      ['delve', 'dig'],
+      ['delves', 'digs'],
+      'tapestry',
+      ['utilize', 'use'],
+      ['utilizes', 'uses'],
+      ['utilizing', 'using'],
+      ['utilized', 'used'],
+      ['a plethora of', 'many'],
+      ['a myriad of', 'many'],
+      ['myriad', 'many'],
+      ['embark on', 'start'],
+      ['embarks on', 'starts'],
+      ['embarking on', 'starting'],
+      'ever-evolving',
+      'ever-changing landscape',
+      'seamlessly',
+      'meticulously',
+      'meticulous',
+      'bustling',
+      'labyrinth',
+      'symphony of',
+      'treasure trove',
+      'beacon of',
+      'paradigm shift',
+      'synergy',
+      'synergies',
+      'commendable',
+    ],
+  }),
+  phraseRule({
+    id: 'en/weasel-vocabulary',
+    lang,
+    category: 'vocabulary',
+    severity: 'info',
+    message: 'Vague word that language models lean on. Fine once, suspicious in bulk.',
+    phrases: [
+      'robust',
+      'seamless',
+      'pivotal',
+      'crucial',
+      'intricate',
+      'multifaceted',
+      'nuanced',
+      'vibrant',
+      'leverage',
+      'leveraging',
+      'elevate',
+      'elevating',
+      'foster',
+      'fostering',
+      'underscore',
+      'underscores',
+      'showcase',
+      'showcasing',
+      'boasts',
+      'paramount',
+      'transformative',
+      'cutting-edge',
+      'revolutionize',
+      'revolutionizes',
+      'holistic',
+      'empower',
+      'empowers',
+      'furthermore',
+      'moreover',
+      'additionally',
+      'realm',
+      'landscape',
+      'journey',
+    ],
+  }),
+  regexRule({
+    id: 'en/not-x-but-y',
+    lang,
+    category: 'structure',
+    severity: 'warning',
+    message: '"It\'s not X, it\'s Y" construction. One of the strongest AI tells.',
+    patterns: [
+      /(?<![\p{L}])[\p{L}\p{N}-]+(?:(?:['’]s| is| was) not| isn['’]t| wasn['’]t) (?:just |only |merely |simply |about )?[^.!?\n]{1,80}?[,;.:\u2014]\s*(?:it|this|that|they)(?:['’]s|['’]re| is| was| are)(?![\p{L}])/giu,
+      /(?<![\p{L}])not because [^.!?\n]{1,80}?[,;\u2014]?\s*but because(?![\p{L}])/giu,
+    ],
+  }),
+  regexRule({
+    id: 'en/whether-youre',
+    lang,
+    category: 'structure',
+    severity: 'info',
+    message: '"Whether you\'re a X or a Y" opener. Generic audience framing.',
+    patterns: [/(?<![\p{L}])whether you(?:['’]re| are)\b[^.!?\n]{1,80}?(?<![\p{L}])or(?![\p{L}])/giu],
+  }),
+];

package/src/rules/fr.js

@@ -0,0 +1,206 @@
+import { phraseRule, regexRule } from './helpers.js';
+
+// Règles françaises. Pour ajouter une expression, ajoutez une ligne dans la bonne liste.
+// "expression" la signale, ["expression", "remplacement"] la corrige aussi avec --fix.
+
+const lang = 'fr';
+
+export default [
+  phraseRule({
+    id: 'fr/chatbot-artifact',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: "Reste de chatbot. Ce texte a été copié depuis un assistant IA.",
+    phrases: [
+      "en tant qu'IA",
+      "en tant qu'intelligence artificielle",
+      'en tant que modèle de langage',
+      'en tant que grand modèle de langage',
+      'ma date de coupure',
+      'mes connaissances s\'arrêtent',
+      "je n'ai pas accès à internet",
+      "j'espère que ce message vous trouve en bonne santé",
+      'je serais ravi de vous aider',
+      'je serais ravie de vous aider',
+      'excellente question',
+      'très bonne question',
+      'voici un résumé détaillé',
+      'voici une analyse détaillée',
+      'voici un aperçu complet',
+    ],
+  }),
+  regexRule({
+    id: 'fr/sycophantic-opener',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: "Formule d'ouverture typique de chatbot. Supprimée avec --fix.",
+    patterns: [/^[ \t]*(?:bien sûr|absolument|avec plaisir|certainement)[   ]?![ \t]*/gimu],
+    fix: '',
+  }),
+  regexRule({
+    id: 'fr/chatbot-sign-off',
+    lang,
+    category: 'chatbot',
+    severity: 'error',
+    message: 'Formule de fin de chatbot. La phrase entière est supprimée avec --fix.',
+    patterns: [
+      /(?:(?<=[.!?:])[ \t]+|^[ \t]*)(?:j['’]espère que (?:cela|ça|ceci) (?:vous |t['’])?(?:aide|aidera|sera utile|a aidé)|n['’]hésitez pas (?:si vous avez|à (?:me|nous) (?:contacter|poser|faire signe|solliciter))|si vous avez (?:d['’]autres|des) questions)[^.!?\n]*[.!?]*/gimu,
+    ],
+    fix: '',
+  }),
+  phraseRule({
+    id: 'fr/filler-opener',
+    lang,
+    category: 'filler',
+    severity: 'warning',
+    message: 'Formule de remplissage. Supprimez-la et allez droit au but.',
+    drop: true,
+    phrases: [
+      'il est important de noter que',
+      'il est important de souligner que',
+      'il est important de rappeler que',
+      'il est essentiel de noter que',
+      'il est essentiel de souligner que',
+      'il est intéressant de noter que',
+      'il convient de noter que',
+      'il convient de souligner que',
+      'il est à noter que',
+      'force est de constater que',
+      "dans le monde d'aujourd'hui,",
+      'dans le monde actuel,',
+      'dans un monde en constante évolution,',
+      'dans un monde en perpétuelle évolution,',
+      "à l'ère du numérique,",
+      "à l'ère du digital,",
+      'sans plus attendre,',
+      'en conclusion,',
+      'en résumé,',
+      'pour conclure,',
+      'en définitive,',
+      'en somme,',
+    ],
+  }),
+  phraseRule({
+    id: 'fr/hype-intro',
+    lang,
+    category: 'filler',
+    severity: 'warning',
+    message: "Accroche ou transition grandiloquente typique d'un texte généré.",
+    phrases: [
+      'plongeons dans',
+      'plongeons au cœur de',
+      'plongeons ensemble',
+      'plongeons sans plus attendre',
+      'embarquons pour',
+      'découvrons ensemble',
+      'explorons ensemble',
+      'naviguer dans les méandres',
+      'naviguer dans le paysage',
+      'dans le paysage numérique',
+      'dans le paysage actuel',
+      'joue un rôle crucial',
+      'joue un rôle essentiel',
+      'joue un rôle clé',
+      'joue un rôle prépondérant',
+      'témoigne de',
+      'un véritable atout',
+      'un atout majeur',
+      'change la donne',
+      'changer la donne',
+      'révolutionne la manière',
+      'à un tout autre niveau',
+      'passer au niveau supérieur',
+      'libérer tout le potentiel',
+      'exploiter tout le potentiel',
+      'tirer pleinement parti',
+    ],
+  }),
+  phraseRule({
+    id: 'fr/ai-vocabulary',
+    lang,
+    category: 'vocabulary',
+    severity: 'warning',
+    message: 'Mot ou expression très surutilisé par les modèles de langage.',
+    phrases: [
+      'incontournable',
+      'incontournables',
+      'pierre angulaire',
+      'tapisserie',
+      'riche tapisserie',
+      'en constante évolution',
+      'en perpétuelle évolution',
+      'game-changer',
+      'game changer',
+      'véritable mine d\'or',
+      'subtiles nuances',
+      'riche et varié',
+      'riche et variée',
+      ["s'avère être", 'est'],
+      ["s'avèrent être", 'sont'],
+      ['de manière significative', 'nettement'],
+      ['de façon significative', 'nettement'],
+      ['un large éventail de', 'de nombreux'],
+      ['une pléthore de', 'beaucoup de'],
+      ['une myriade de', 'beaucoup de'],
+      ['une multitude de', 'beaucoup de'],
+    ],
+  }),
+  phraseRule({
+    id: 'fr/weasel-vocabulary',
+    lang,
+    category: 'vocabulary',
+    severity: 'info',
+    message: "Mot vague sur lequel s'appuient les IA. Acceptable une fois, suspect en série.",
+    phrases: [
+      'véritable',
+      'crucial',
+      'cruciale',
+      'cruciaux',
+      'au cœur de',
+      'fascinant',
+      'fascinante',
+      'holistique',
+      'synergie',
+      'levier',
+      'leviers',
+      'booster',
+      'sublimer',
+      'propulser',
+      'optimal',
+      'optimale',
+      'robuste',
+      'harmonieux',
+      'harmonieuse',
+      'dynamique',
+      'innovant',
+      'innovante',
+      'novateur',
+      'novatrice',
+      'en outre',
+      'par ailleurs',
+      'de surcroît',
+    ],
+  }),
+  regexRule({
+    id: 'fr/not-x-but-y',
+    lang,
+    category: 'structure',
+    severity: 'warning',
+    message: "Construction « ce n'est pas X, c'est Y ». L'un des tics IA les plus reconnaissables.",
+    patterns: [
+      /(?<![\p{L}])[\p{L}\p{N}-]+\s+n['’](?:est|était)\s+pas\s+(?:seulement\s+|juste\s+|simplement\s+|uniquement\s+|qu['’]une?\s+)?[^.!?\n]{1,80}?[,;.:\u2014]\s*(?:c['’](?:est|était)|il\s+s['’]agit)(?![\p{L}])/giu,
+      /(?<![\p{L}])il\s+ne\s+s['’]agit\s+pas\s+(?:seulement\s+|simplement\s+|juste\s+|uniquement\s+)?d(?:e\s+|['’])[^.!?\n]{1,80}?,?\s*mais\s+(?:bien\s+|aussi\s+|surtout\s+)?d(?:e|['’])(?![\p{L}])/giu,
+      /(?<![\p{L}])plus\s+qu['’]une?\s+[^.!?\n]{1,60}?,\s*(?:c['’]est|un|une)(?![\p{L}])/giu,
+    ],
+  }),
+  regexRule({
+    id: 'fr/que-vous-soyez',
+    lang,
+    category: 'structure',
+    severity: 'info',
+    message: "Accroche « Que vous soyez X ou Y ». Cadrage d'audience générique.",
+    patterns: [/(?<![\p{L}])que\s+vous\s+soyez(?![\p{L}])[^.!?\n]{1,80}?(?<![\p{L}])ou(?![\p{L}])/giu],
+  }),
+];

package/src/rules/helpers.js

@@ -0,0 +1,94 @@
+// Small builders so that adding a rule is one line in a list.
+// Every rule is { id, lang, category, severity, message, find(text, ctx) }.
+// find() yields { index, length, fix?, message? }. fix === undefined or null means "no autofix".
+
+const BEFORE = '(?<![\\p{L}\\p{N}_])';
+const AFTER = '(?![\\p{L}\\p{N}_])';
+
+export function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Turns a plain phrase into a tolerant regex source:
+// any apostrophe matches ' or the typographic one, any space matches any whitespace run.
+export function phraseSource(phrase) {
+  return escapeRegex(phrase)
+    .replace(/['’]/g, "['’]")
+    .replace(/\s+/g, '\\s+');
+}
+
+export function isUpper(ch) {
+  return !!ch && ch !== ch.toLowerCase() && ch === ch.toUpperCase();
+}
+
+export function matchCase(replacement, original) {
+  if (!replacement) return replacement;
+  if (isUpper(original[0])) return replacement[0].toUpperCase() + replacement.slice(1);
+  return replacement;
+}
+
+/**
+ * A rule built from a list of phrases.
+ * Each entry is either "phrase" (report only) or ["phrase", "replacement"].
+ * With drop: true, the phrase is removed and the next word is capitalized when the phrase opened a sentence.
+ */
+export function phraseRule({ id, lang, category, severity, message, phrases, drop = false }) {
+  const entries = phrases
+    .map((p) => (Array.isArray(p) ? { phrase: p[0], replacement: p[1] } : { phrase: p, replacement: undefined }))
+    .sort((a, b) => b.phrase.length - a.phrase.length);
+
+  const lookup = new Map(entries.map((e) => [normalize(e.phrase), e]));
+  const body = entries.map((e) => phraseSource(e.phrase)).join('|');
+  // In drop mode we also eat the trailing spaces and capture the next letter so we can re-case it.
+  const source = drop ? `${BEFORE}(${body})(?:${AFTER})([ \\t]*)(\\p{L})?` : `${BEFORE}(${body})${AFTER}`;
+
+  return {
+    id,
+    lang,
+    category,
+    severity,
+    message,
+    *find(text) {
+      const re = new RegExp(source, 'giu');
+      for (const m of text.matchAll(re)) {
+        const matched = m[1];
+        const entry = lookup.get(normalize(matched));
+        if (drop) {
+          const next = m[3] || '';
+          const opensSentence = isUpper(matched[0]);
+          const fixedNext = opensSentence ? next.toUpperCase() : next;
+          // Report only the phrase, but let the fix also re-case the letter that follows it.
+          yield { index: m.index, length: matched.length, fixLength: m[0].length, fix: fixedNext, fixLabel: '(remove)', quote: matched };
+        } else {
+          const fix = entry && entry.replacement !== undefined ? matchCase(entry.replacement, matched) : undefined;
+          yield { index: m.index, length: matched.length, fix, quote: matched };
+        }
+      }
+    },
+  };
+}
+
+/** A rule built from one or more regexes. fix can be a string or a function(match, text) returning a string or null. */
+export function regexRule({ id, lang, category, severity, message, patterns, fix }) {
+  return {
+    id,
+    lang,
+    category,
+    severity,
+    message,
+    *find(text, ctx) {
+      for (const pattern of patterns) {
+        const re = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g');
+        for (const m of text.matchAll(re)) {
+          if (m[0].length === 0) continue;
+          const f = typeof fix === 'function' ? fix(m, text, ctx) : fix;
+          yield { index: m.index, length: m[0].length, fix: f ?? undefined, quote: m[0].trim() };
+        }
+      }
+    },
+  };
+}
+
+function normalize(s) {
+  return s.toLowerCase().replace(/’/g, "'").replace(/\s+/g, ' ');
+}