slopfix 0.0.0-stage → 0.1.0

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,93 @@
+// 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;
+          yield { index: m.index, length: 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, ' ');
+}