ai-text-check 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,5 +1,6 @@
-import 'fs';
-import 'path';
+import { lintText } from 'ai-slop-linter';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
 import 'url';
 import { analyze } from 'is-this-ai-slop';
 import { createRequire } from 'module';
@@ -565,6 +566,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   strict: {
@@ -575,6 +579,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   ai: {
@@ -585,6 +592,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: true,
     veldica: true,
     cleanWriting: true,
+    aiSlopLinter: true,
+    slopDetector: true,
+    proseSlop: true,
     vale: true
   },
   grammar: {
@@ -595,6 +605,9 @@ var ENGINE_PRESETS = {
     isThisAiSlop: false,
     veldica: false,
     cleanWriting: true,
+    aiSlopLinter: false,
+    slopDetector: false,
+    proseSlop: false,
     vale: true
   }
 };
@@ -615,6 +628,9 @@ var ENGINE_KEYS = [
   "isThisAiSlop",
   "veldica",
   "cleanWriting",
+  "aiSlopLinter",
+  "slopDetector",
+  "proseSlop",
   "vale"
 ];
 function isObject(value) {
@@ -734,6 +750,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");
@@ -867,6 +891,7 @@ function validateUserConfig(value) {
     "failOn",
     "minScore",
     "ignoreRules",
+    "ignoreEmojis",
     "include",
     "exclude",
     "extensions",
@@ -890,7 +915,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(
@@ -927,6 +959,27 @@ function defineConfig(config) {
 function isStrictPreset(config) {
   return config.preset === "strict";
 }
+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) {
@@ -1896,7 +1949,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";
@@ -1916,7 +1969,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,
@@ -1943,6 +1996,33 @@ function runIsThisAiSlop(text) {
     return issue;
   });
 }
+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 = [];
@@ -2904,10 +2984,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) {
@@ -2917,21 +2997,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,
@@ -2960,14 +3040,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) {
@@ -9860,9 +9940,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname3) {
+  set dirname(dirname4) {
     assertPath2(this.basename, "dirname");
-    this.path = minpath.join(dirname3 || "", this.basename);
+    this.path = minpath.join(dirname4 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -10885,6 +10965,160 @@ function runRetext(text) {
     return issue;
   });
 }
+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 = createRequire(import.meta.url);
+var assetsDir = join(
+  dirname(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(
+    readFileSync(join(assetsDir, "slop_list.json"), "utf8")
+  );
+  const trigramsRaw = JSON.parse(
+    readFileSync(join(assetsDir, "slop_list_trigrams.json"), "utf8")
+  );
+  const leaderboard = JSON.parse(
+    readFileSync(join(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) {
@@ -11256,7 +11490,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);
@@ -11278,7 +11512,7 @@ function tokenize(text) {
     }
   };
 }
-var tokenizeProse = tokenize;
+var tokenizeProse = tokenize2;
 
 // node_modules/@veldica/prose-analyzer/dist/utils.js
 function round(value, decimals = 4) {
@@ -12022,7 +12256,7 @@ function inventoryMarkers(text, options = {}) {
 }
 
 // src/engines/veldica.ts
-function toSeverity2(value) {
+function toSeverity4(value) {
   if (value === "high") return "warn";
   return "info";
 }
@@ -12037,7 +12271,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
@@ -12050,8 +12284,8 @@ function runVeldica(text) {
     return issue;
   });
 }
-var require2 = createRequire(import.meta.url);
-var writeGood = require2("write-good");
+var require4 = createRequire(import.meta.url);
+var writeGood = require4("write-good");
 function runWriteGood(text) {
   const suggestions = writeGood(text, {
     so: false,
@@ -12275,6 +12509,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",
@@ -13143,7 +13385,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 = [];
@@ -13216,6 +13458,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)
@@ -13231,7 +13485,8 @@ function checkText(text, options = {}) {
     body,
     parsed.frontmatter,
     format,
-    config
+    config,
+    source2
   );
   const title = String(parsed.frontmatter.title ?? pathBasename(source2));
   const report = {