ai-text-check 1.0.0 → 1.2.0

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) {
@@ -736,6 +751,14 @@ function validateUserConfig(value) {
       config.ignoreRules = value.ignoreRules;
     }
   }
+  const ignoreEmojis = expectBoolean(
+    value.ignoreEmojis,
+    "ignoreEmojis",
+    errors
+  );
+  if (ignoreEmojis !== void 0) {
+    config.ignoreEmojis = ignoreEmojis;
+  }
   if (value.include !== void 0) {
     if (!isStringArray(value.include)) {
       errors.push("include must be an array of strings");
@@ -869,6 +892,7 @@ function validateUserConfig(value) {
     "failOn",
     "minScore",
     "ignoreRules",
+    "ignoreEmojis",
     "include",
     "exclude",
     "extensions",
@@ -892,7 +916,14 @@ function resolveConfig(user = {}) {
     format: user.format ?? "auto",
     failOn: user.failOn ?? "warn",
     minScore: user.minScore ?? 0,
-    ignoreRules: user.ignoreRules ?? [],
+    ignoreRules: (() => {
+      const rules = [...user.ignoreRules ?? []];
+      if (user.ignoreEmojis ?? false) {
+        rules.push("ai-emojis");
+      }
+      return rules;
+    })(),
+    ignoreEmojis: user.ignoreEmojis ?? false,
     include: user.include ?? [],
     exclude: user.exclude ?? [],
     extensions: (user.extensions ?? DEFAULT_EXTENSIONS).map(
@@ -925,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, " ");
@@ -1941,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";
@@ -1961,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,
@@ -1992,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) {
@@ -2952,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) {
@@ -2965,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,
@@ -3008,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) {
@@ -9660,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'`).
@@ -10696,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 }));
@@ -11066,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);
@@ -11088,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) {
@@ -11832,7 +12076,7 @@ function inventoryMarkers(text, options = {}) {
 }
 
 // src/engines/veldica.ts
-function toSeverity2(value) {
+function toSeverity4(value) {
   if (value === "high") return "warn";
   return "info";
 }
@@ -11847,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
@@ -11862,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,
@@ -12088,6 +12332,14 @@ var AI_PATTERN_RULES = [
     severity: "info",
     minCount: ({ words }) => Math.max(6, words / 250)
   },
+  {
+    id: "ai-emojis",
+    category: "ai",
+    pattern: new RegExp("\\p{Extended_Pictographic}", "gu"),
+    message: "Emoji can read as chatty or AI-styled in formal prose.",
+    severity: "info",
+    suggestion: "Prefer plain prose, or set ignoreEmojis: true to allow them."
+  },
   {
     id: "double-space",
     category: "typography",
@@ -12952,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 = [];
@@ -13025,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)
@@ -13040,7 +13304,8 @@ function checkText(text, options = {}) {
     body,
     parsed.frontmatter,
     format,
-    config
+    config,
+    source2
   );
   const title = String(parsed.frontmatter.title ?? pathBasename(source2));
   const report = {
@@ -13073,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) {
@@ -13116,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(
@@ -13173,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";
@@ -13200,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];
@@ -13435,6 +13700,7 @@ Options:
   --no-slop          Skip slop-gate vocabulary and is-this-ai-slop
   --no-write-good    Skip the write-good grammar engine
   --no-retext        Skip retext (passive, readability, simplify, repeats)
+  --ignore-emojis    Allow emojis (skip the ai-emojis rule; off by default)
   --ignore-rule ID   Ignore a rule (repeatable)
   --config PATH      Path to ai-text-check.config.json
   --help, -h         Show this help
@@ -13442,7 +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.
+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
@@ -13463,6 +13731,7 @@ function parseArgs(argv) {
     slop: true,
     writeGood: true,
     retext: true,
+    ignoreEmojis: false,
     ignoreRules: [],
     valeArgs: []
   };
@@ -13528,6 +13797,9 @@ function parseArgs(argv) {
       case "--no-retext":
         options.retext = false;
         break;
+      case "--ignore-emojis":
+        options.ignoreEmojis = true;
+        break;
       case "--min-score": {
         const value = Number(args[++i]);
         if (!Number.isFinite(value)) {
@@ -13588,6 +13860,7 @@ function toUserConfig(options) {
   if (options.failOn) config.failOn = options.failOn;
   if (options.minScore !== void 0) config.minScore = options.minScore;
   if (options.ignoreRules.length > 0) config.ignoreRules = options.ignoreRules;
+  if (options.ignoreEmojis) config.ignoreEmojis = true;
   const engines = {};
   if (!options.vale) engines.vale = false;
   if (!options.slop) {
@@ -13603,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) {
@@ -13618,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));
@@ -13648,7 +13921,8 @@ var SAMPLE_CONFIG = `{
   "failOn": "warn",
   "minScore": 0,
   "extensions": [".md", ".mdx", ".markdown", ".txt"],
-  "ignoreRules": []
+  "ignoreRules": [],
+  "ignoreEmojis": false
 }
 `;
 function initProject(cwd, withVale) {