ai-text-check 1.1.0 → 1.2.0

package/README.md

@@ -23,6 +23,9 @@ Node.js 20+ is required. The package ships dual **ESM and CommonJS** builds with
 | **is-this-ai-slop** | Clichés, buzzwords, em-dash spam, antithesis, sycophancy                                                           |
 | **veldica**         | Stock LLM transitions and AI-style markers                                                                         |
 | **clean-writing**   | Banned constructions, marketing adjectives, filler, intensifiers                                                   |
+| **ai-slop-linter**  | Wikipedia _Signs of AI writing_ rules with line/column findings                                                    |
+| **slop-detector**   | EQBench SLOP score (vocabulary, contrast patterns, trigrams, tropes)                                               |
+| **prose-slop**      | Vocabulary, punctuation, and document-cadence tells (English)                                                      |
 | **vale**            | Vendored styles: write-good, Google, AiTextCheck, ai-tells, signs-of-ai-writing                                    |
 
 Safe auto-fixes can strip filler openers and collapse extra whitespace without rewriting code fences.
@@ -146,6 +149,9 @@ Exit code `1` when issues meet the fail threshold.
     "isThisAiSlop": true,
     "veldica": true,
     "cleanWriting": true,
+    "aiSlopLinter": true,
+    "slopDetector": true,
+    "proseSlop": true,
     "vale": true
   }
 }
@@ -155,7 +161,7 @@ Presets:
 
 - `default`: every check and every engine
 - `strict`: default plus extra slop-gate punctuation
-- `ai`: AI tells + typography (polish, slop-gate, is-this-ai-slop, Veldica, clean-writing, Vale)
+- `ai`: AI tells + typography (polish, slop-gate, is-this-ai-slop, Veldica, clean-writing, ai-slop-linter, slop-detector, prose-slop, Vale)
 - `grammar`: grammar + readability (write-good, retext, clean-writing, Vale)
 
 ## Scripts

package/SOURCES.md

@@ -18,17 +18,22 @@ API key. Vale (`@vvago/vale`) is the prose engine the user referred to as Vale
 | is-this-ai-slop                                                                        | `is-this-ai-slop` (`analyze()`)                                                                          |
 | Veldica AI markers                                                                     | `@veldica/prose-linter` (`inventoryMarkers()`)                                                           |
 | Clean Writing / STE subset                                                             | `clean-writing-lint` (`lint()`), with contraction and 20-word sentence rules off                         |
+| ai-slop-linter                                                                         | `ai-slop-linter` (`lintText()`) — Wikipedia Signs of AI writing                                          |
+| slop-detector (EQBench)                                                                | `slop-detector` scoring assets + sync adapter (`runSlopDetector`)                                        |
+| prose-slop                                                                             | `prose-slop` (`check()`) — EN vocabulary / cadence                                                       |
 
 Skipped after research (not a fit for Node 20 in-process checks):
 
 - `slopsift` / WritingLint — requires Node 24+
-- `slopless` — textlint-only, async
+- `slopless` — textlint-only, async, Node ≥22.13
 - `wsc-lint` / `tacheles` — CLI-only, no stable in-process API
+- `smellcheck` (npm) — agent skill / Markdown rules only; does not scan text
+- `llm-slop-detector` — VS Code–centric, awkward as a library dependency
 - Hosted classifiers (GPTZero, Originality, etc.) — need secrets / upload text
 
 Default `checkFiles` order: polish + slop-gate JSON + write-good + retext +
-is-this-ai-slop + Veldica + clean-writing, then Vale JSON merged onto the same
-report.
+is-this-ai-slop + Veldica + clean-writing + ai-slop-linter + slop-detector +
+prose-slop, then Vale JSON merged onto the same report.
 
 Licenses for this package and the vendored Vale styles are in [LICENSE](./LICENSE)
 and [NOTICE](./NOTICE).

package/dist/cli.js

@@ -567,6 +567,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   strict: {
@@ -577,6 +580,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   ai: {
@@ -587,6 +593,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   grammar: {
@@ -597,6 +606,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: false,
     veldica: false,
     cleanWriting: true,
+    aiSlopLinter: false,
+    slopDetector: false,
+    proseSlop: false,
     vale: true
   }
 };
@@ -617,6 +629,9 @@ var ENGINE_KEYS = [
   "isThisAiSlop",
   "veldica",
   "cleanWriting",
+  "aiSlopLinter",
+  "slopDetector",
+  "proseSlop",
   "vale"
 ];
 function isObject(value) {
@@ -941,6 +956,30 @@ function isStrictPreset(config) {
 // src/node/check-files.ts
 import fs3 from "fs";
 
+// src/engines/ai-slop-linter.ts
+import { lintText } from "ai-slop-linter";
+function toSeverity(value) {
+  if (value === "error") return "error";
+  if (value === "warning" || value === "warn") return "warn";
+  return "info";
+}
+function runAiSlopLinter(text, options = {}) {
+  const result = lintText(options.source ?? "<text>", text, { floor: 0 });
+  return result.findings.map((finding) => {
+    const issue = {
+      rule: `asl-${finding.rule}`,
+      engine: "ai-slop-linter",
+      category: "ai",
+      severity: toSeverity(finding.severity),
+      message: finding.message,
+      line: finding.line,
+      column: finding.column,
+      excerpt: finding.excerpt
+    };
+    return issue;
+  });
+}
+
 // node_modules/clean-writing-lint/src/mask.js
 function blank(text) {
   return text.replace(/[^\n]/g, " ");
@@ -1957,7 +1996,7 @@ var AI_RULES = /* @__PURE__ */ new Set([
   "banned-construction",
   "em-dash"
 ]);
-function toSeverity(value) {
+function toSeverity2(value) {
   if (value === "error") return "error";
   if (value === "warn") return "warn";
   return "info";
@@ -1977,7 +2016,7 @@ function runCleanWriting(text) {
       rule: `cws-${violation.rule}`,
       engine: "clean-writing",
       category: AI_RULES.has(violation.rule) ? "ai" : "grammar",
-      severity: toSeverity(violation.severity),
+      severity: toSeverity2(violation.severity),
       message: violation.message,
       line: violation.line,
       column: violation.column,
@@ -2008,6 +2047,36 @@ function runIsThisAiSlop(text) {
   });
 }
 
+// src/engines/prose-slop.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var { check } = require2("prose-slop");
+function toSeverity3(value) {
+  if (value === "error") return "error";
+  if (value === "warning" || value === "warn") return "warn";
+  return "info";
+}
+function runProseSlop(text, options = {}) {
+  const findings = check(text, {
+    format: options.format ?? "plain",
+    lang: "en"
+  });
+  return findings.map((finding) => {
+    const issue = {
+      rule: `prose-${finding.ruleId}`,
+      engine: "prose-slop",
+      category: "ai",
+      severity: toSeverity3(finding.severity),
+      message: finding.message,
+      line: finding.line,
+      column: finding.column,
+      excerpt: excerptAround(text, finding.index),
+      match: finding.match
+    };
+    return issue;
+  });
+}
+
 // node_modules/nlcst-to-string/lib/index.js
 var emptyNodes = [];
 function toString(value) {
@@ -2968,10 +3037,10 @@ function anyFactory(tests) {
     return false;
   }
 }
-function propertiesFactory(check) {
+function propertiesFactory(check2) {
   const checkAsRecord = (
     /** @type {Record<string, unknown>} */
-    check
+    check2
   );
   return castFactory(all);
   function all(node) {
@@ -2981,21 +3050,21 @@ function propertiesFactory(check) {
       node
     );
     let key;
-    for (key in check) {
+    for (key in check2) {
       if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
     }
     return true;
   }
 }
-function typeFactory(check) {
+function typeFactory(check2) {
   return castFactory(type);
   function type(node) {
-    return node && node.type === check;
+    return node && node.type === check2;
   }
 }
 function castFactory(testFunction) {
-  return check;
-  function check(value, index2, parent) {
+  return check2;
+  function check2(value, index2, parent) {
     return Boolean(
       looksLikeANode(value) && testFunction.call(
         this,
@@ -3024,14 +3093,14 @@ var CONTINUE = true;
 var EXIT = false;
 var SKIP = "skip";
 function visitParents(tree, test, visitor, reverse) {
-  let check;
+  let check2;
   if (typeof test === "function" && typeof visitor !== "function") {
     reverse = visitor;
     visitor = test;
   } else {
-    check = test;
+    check2 = test;
   }
-  const is2 = convert(check);
+  const is2 = convert(check2);
   const step = reverse ? -1 : 1;
   factory(tree, void 0, [])();
   function factory(node, index2, parents) {
@@ -9676,9 +9745,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname2) {
+  set dirname(dirname3) {
     assertPath(this.basename, "dirname");
-    this.path = default2.join(dirname2 || "", this.basename);
+    this.path = default2.join(dirname3 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -10712,6 +10781,165 @@ function runRetext(text) {
   });
 }
 
+// src/engines/slop-detector.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join3 } from "path";
+var WEIGHT_WORD = 0.5;
+var WEIGHT_PATTERN = 0.2;
+var WEIGHT_TRIGRAM = 0.12;
+var WEIGHT_TROPE = 0.18;
+var WORD_MULTIPLIER = 1e3;
+var TRIGRAM_MULTIPLIER = 1e3;
+var CONTRAST_PATTERN = /\b(?:it(?:'s| is)|this is|that(?:'s| is)|(?:it|this|that) isn'?t)\s+(?:just |only |merely |simply )?[a-z][\s\S]{0,80}?\b(?:it(?:'s| is)|this is|that(?:'s| is)|but)\b/gi;
+var NOT_BUT_PATTERN = /\bnot\b[\s\S]{0,60}?\bbut\b/gi;
+var require3 = createRequire2(import.meta.url);
+var assetsDir = join3(
+  dirname2(require3.resolve("slop-detector/package.json")),
+  "dist",
+  "assets"
+);
+var cachedAssets = null;
+function computeRange(values) {
+  if (values.length === 0) return { min: 0, max: 1 };
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  return { min: min - range * 0.1, max: max + range * 0.1 };
+}
+function loadAssets() {
+  if (cachedAssets) return cachedAssets;
+  const wordsRaw = JSON.parse(
+    readFileSync3(join3(assetsDir, "slop_list.json"), "utf8")
+  );
+  const trigramsRaw = JSON.parse(
+    readFileSync3(join3(assetsDir, "slop_list_trigrams.json"), "utf8")
+  );
+  const leaderboard = JSON.parse(
+    readFileSync3(join3(assetsDir, "leaderboard_results.json"), "utf8")
+  );
+  const words = /* @__PURE__ */ new Set();
+  for (const item of wordsRaw) {
+    if (Array.isArray(item) && item[0]) words.add(item[0].toLowerCase());
+  }
+  const trigrams = /* @__PURE__ */ new Set();
+  for (const item of trigramsRaw) {
+    if (Array.isArray(item) && item[0]) trigrams.add(item[0].toLowerCase());
+  }
+  const metrics = {
+    slop_words: [],
+    slop_trigrams: [],
+    contrast: []
+  };
+  for (const res of leaderboard.results ?? []) {
+    if (!res.metrics) continue;
+    metrics.slop_words.push(res.metrics.slop_list_matches_per_1k_words || 0);
+    metrics.slop_trigrams.push(
+      res.metrics.slop_trigram_matches_per_1k_words || 0
+    );
+    metrics.contrast.push(res.metrics.not_x_but_y_per_1k_chars || 0);
+  }
+  cachedAssets = {
+    words,
+    trigrams,
+    normalizationRanges: {
+      slop_words: computeRange(metrics.slop_words),
+      slop_trigrams: computeRange(metrics.slop_trigrams),
+      contrast: computeRange(metrics.contrast)
+    }
+  };
+  return cachedAssets;
+}
+function normalizeValue(value, range) {
+  const normalized = (value - range.min) / (range.max - range.min);
+  return Math.max(0, Math.min(1, normalized));
+}
+function toPlainText(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`\n]+`/g, " ").replace(/<[^>]+>/g, " ").replace(/!\[[^\]]*]\([^)]*\)/g, " ").replace(/\[[^\]]*]\([^)]*\)/g, " ").replace(/^#{1,6}\s+/gm, "").replace(/[*_~>#-]+/g, " ");
+}
+function tokenize(text) {
+  return text.toLowerCase().match(/[a-z]+(?:'[a-z]+)?/g) ?? [];
+}
+function collectMatches(pattern, text) {
+  return [...text.matchAll(pattern)].map((match) => match[0] ?? "");
+}
+function runSlopDetector(text) {
+  if (!text.trim()) return [];
+  const assets = loadAssets();
+  const plain = toPlainText(text);
+  const tokens = tokenize(plain);
+  const nTokens = tokens.length || 1;
+  let wordHitCount = 0;
+  const wordHitMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    if (!assets.words.has(token)) continue;
+    wordHitCount++;
+    wordHitMap.set(token, (wordHitMap.get(token) || 0) + 1);
+  }
+  let trigramHitCount = 0;
+  if (tokens.length >= 3) {
+    for (let i = 0; i < tokens.length - 2; i++) {
+      const tg = `${tokens[i]} ${tokens[i + 1]} ${tokens[i + 2]}`;
+      if (assets.trigrams.has(tg)) trigramHitCount++;
+    }
+  }
+  const contrastMatches = [
+    .../* @__PURE__ */ new Set([
+      ...collectMatches(CONTRAST_PATTERN, plain),
+      ...collectMatches(NOT_BUT_PATTERN, plain)
+    ])
+  ];
+  const emDashCount = (text.match(/—/g) ?? []).length;
+  const tropeRate = emDashCount / Math.max(plain.length, 1) * 1e3;
+  const wordScore = wordHitCount / nTokens * WORD_MULTIPLIER;
+  const trigramScore = trigramHitCount / nTokens * TRIGRAM_MULTIPLIER;
+  const contrastScore = contrastMatches.length / Math.max(plain.length, 1) * 1e3;
+  const rawSlopScore = (normalizeValue(wordScore, assets.normalizationRanges.slop_words) * WEIGHT_WORD + normalizeValue(contrastScore, assets.normalizationRanges.contrast) * WEIGHT_PATTERN + normalizeValue(trigramScore, assets.normalizationRanges.slop_trigrams) * WEIGHT_TRIGRAM + normalizeValue(tropeRate, { min: 0, max: 5 }) * WEIGHT_TROPE) * 100;
+  const slopScore = Math.round(rawSlopScore * 10) / 10;
+  const issues = [];
+  if (slopScore >= 40) {
+    issues.push({
+      rule: "eqbench-slop-score",
+      engine: "slop-detector",
+      category: "ai",
+      severity: slopScore >= 60 ? "warn" : "info",
+      message: `EQBench SLOP score ${slopScore}/100 (higher = more AI-like).`,
+      suggestion: slopScore >= 60 ? "Rewrite stock phrasing and contrast constructions." : "Review flagged vocabulary and contrast patterns."
+    });
+  }
+  for (const [word2, count] of [...wordHitMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8)) {
+    issues.push({
+      rule: `eqbench-word-${word2.replace(/\s+/g, "-")}`,
+      engine: "slop-detector",
+      category: "ai",
+      severity: "info",
+      message: `EQBench slop vocabulary: \u201C${word2}\u201D (${count}\xD7).`,
+      match: word2
+    });
+  }
+  for (const match of contrastMatches.slice(0, 5)) {
+    issues.push({
+      rule: "eqbench-contrast",
+      engine: "slop-detector",
+      category: "ai",
+      severity: "info",
+      message: `EQBench contrast pattern: \u201C${match.trim()}\u201D`,
+      match
+    });
+  }
+  if (emDashCount >= 3) {
+    issues.push({
+      rule: "eqbench-trope-em-dash",
+      engine: "slop-detector",
+      category: "ai",
+      severity: "info",
+      message: `EQBench typography trope: ${emDashCount} em dash(es).`,
+      match: "\u2014"
+    });
+  }
+  return issues;
+}
+
 // src/engines/tag.ts
 function tagEngine(issues, engine) {
   return issues.map((issue) => ({ ...issue, engine }));
@@ -11082,7 +11310,7 @@ function countListItems(input) {
 function countBlockquotes(input) {
   return getLineMetadata(input).blockquote_count;
 }
-function tokenize(text) {
+function tokenize2(text) {
   const blocks = splitParagraphBlocks(text);
   const paragraphs2 = blocks.map((block) => block.text);
   const sentences2 = splitSentencesFromBlocks(blocks);
@@ -11104,7 +11332,7 @@ function tokenize(text) {
     }
   };
 }
-var tokenizeProse = tokenize;
+var tokenizeProse = tokenize2;
 
 // node_modules/@veldica/prose-analyzer/dist/utils.js
 function round(value, decimals = 4) {
@@ -11848,7 +12076,7 @@ function inventoryMarkers(text, options = {}) {
 }
 
 // src/engines/veldica.ts
-function toSeverity2(value) {
+function toSeverity4(value) {
   if (value === "high") return "warn";
   return "info";
 }
@@ -11863,7 +12091,7 @@ function runVeldica(text) {
       rule: `veldica-${match.category || "marker"}`,
       engine: "veldica",
       category: "ai",
-      severity: toSeverity2(match.severity),
+      severity: toSeverity4(match.severity),
       message: `AI-style marker (${match.category}): \u201C${match.matched_text}\u201D`,
       excerpt: excerptAround(text, offset),
       match: match.matched_text
@@ -11878,9 +12106,9 @@ function runVeldica(text) {
 }
 
 // src/engines/write-good.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var writeGood = require2("write-good");
+import { createRequire as createRequire3 } from "module";
+var require4 = createRequire3(import.meta.url);
+var writeGood = require4("write-good");
 function runWriteGood(text) {
   const suggestions = writeGood(text, {
     so: false,
@@ -12976,7 +13204,7 @@ function computeStats(body, titleLength, descriptionLength, issues) {
     descriptionLength
   };
 }
-function collectIssues(body, frontmatter, format, config) {
+function collectIssues(body, frontmatter, format, config, source2) {
   const ignoreRules = new Set(config.ignoreRules);
   const issues = [];
   const enginesRun = [];
@@ -13049,6 +13277,18 @@ function collectIssues(body, frontmatter, format, config) {
     enginesRun.push("clean-writing");
     issues.push(...runCleanWriting(body));
   }
+  if (config.engines.aiSlopLinter && config.checks.ai) {
+    enginesRun.push("ai-slop-linter");
+    issues.push(...runAiSlopLinter(body, { source: source2 }));
+  }
+  if (config.engines.slopDetector && config.checks.ai) {
+    enginesRun.push("slop-detector");
+    issues.push(...runSlopDetector(body));
+  }
+  if (config.engines.proseSlop && config.checks.ai) {
+    enginesRun.push("prose-slop");
+    issues.push(...runProseSlop(body, { format }));
+  }
   return {
     issues: issues.filter((issue) => !ignoreRules.has(issue.rule)),
     enginesRun: uniqueEngines(enginesRun)
@@ -13064,7 +13304,8 @@ function checkText(text, options = {}) {
     body,
     parsed.frontmatter,
     format,
-    config
+    config,
+    source2
   );
   const title = String(parsed.frontmatter.title ?? pathBasename(source2));
   const report = {
@@ -13097,11 +13338,11 @@ import path2 from "path";
 
 // src/node/vale.ts
 import { spawnSync } from "child_process";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire4 } from "module";
 import fs from "fs";
 import path from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var require3 = createRequire2(import.meta.url);
+var require5 = createRequire4(import.meta.url);
 function packageRoot() {
   let current = path.dirname(fileURLToPath2(import.meta.url));
   while (true) {
@@ -13140,7 +13381,7 @@ function findValeBinary(cwd = process.cwd()) {
   const fromPackage = firstExisting(valeNativeCandidates(packageRoot()));
   if (fromPackage) return fromPackage;
   try {
-    const pkg = require3.resolve("@vvago/vale/package.json");
+    const pkg = require5.resolve("@vvago/vale/package.json");
     const dir = path.dirname(pkg);
     const resolved = firstExisting([
       path.join(
@@ -13197,8 +13438,8 @@ function valeSeverity(value) {
   if (value === "suggestion") return "info";
   return "warn";
 }
-function valeCategory(check) {
-  if (check.startsWith("write-good.") || check.startsWith("Google.")) {
+function valeCategory(check2) {
+  if (check2.startsWith("write-good.") || check2.startsWith("Google.")) {
     return "grammar";
   }
   return "ai";
@@ -13224,13 +13465,13 @@ function collectValeIssues(files, options = {}) {
     const issues = [];
     for (const raw of alerts) {
       const alert = raw;
-      const check = alert.Check ?? "vale";
+      const check2 = alert.Check ?? "vale";
       const issue = {
-        rule: check,
+        rule: check2,
         engine: "vale",
-        category: valeCategory(check),
+        category: valeCategory(check2),
         severity: valeSeverity(alert.Severity),
-        message: alert.Message ?? check
+        message: alert.Message ?? check2
       };
       if (alert.Line) issue.line = alert.Line;
       if (alert.Span?.[0]) issue.column = alert.Span[0];
@@ -13467,8 +13708,9 @@ Options:
   --                 Extra flags after -- are passed to Vale
 
 By default every local engine runs: polish, slop-gate, write-good, retext,
-is-this-ai-slop, Veldica, clean-writing, and Vale. Emoji in prose is flagged
-as an AI tell unless --ignore-emojis (or ignoreEmojis: true) is set.
+is-this-ai-slop, Veldica, clean-writing, ai-slop-linter, slop-detector,
+prose-slop, and Vale. Emoji in prose is flagged as an AI tell unless
+--ignore-emojis (or ignoreEmojis: true) is set.
 
 Examples:
   ai-text-check content
@@ -13634,9 +13876,9 @@ function toUserConfig(options) {
 // src/cli/init.ts
 import fs5 from "fs";
 import path5 from "path";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire5 } from "module";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var require4 = createRequire3(import.meta.url);
+var require6 = createRequire5(import.meta.url);
 function packageVersion() {
   let current = path5.dirname(fileURLToPath3(import.meta.url));
   while (true) {
@@ -13649,7 +13891,7 @@ function packageVersion() {
     if (parent === current) break;
     current = parent;
   }
-  return require4("../../package.json").version;
+  return require6("../../package.json").version;
 }
 function findPackageRoot() {
   let current = path5.dirname(fileURLToPath3(import.meta.url));