slopless 0.2.15 → 0.2.16

package/dist/rules/words/llm-vocabulary.js

@@ -1,5 +1,16 @@
-import { findVocabularyMatches } from "./private/vocabulary-context.js";
-import { oneToOneRule } from "../private/textlint-rule-builders.js";
+import { defineTextlintRule } from "../../adapters/textlint/rule.js";
+import { paragraphUnits } from "../../adapters/textlint/units.js";
+import { wordTokens } from "../../shared/text/tokens.js";
+import { isVocabularyContextAllowed } from "./private/vocabulary-context.js";
+const RULE_ID = "words:llm-vocabulary";
+const GROUP = "llm vocabulary";
+const MAX_PARAGRAPH_TOKENS = 90;
+const MAX_WINDOW_TOKENS = 65;
+const MIN_HITS = 3;
+const WINDOW_SENTENCES = 4;
+// Single stock words like "comprehensive" or "moreover" are ordinary in human
+// prose; flag only when stock LLM diction clusters. (Words that are slop on
+// their own, e.g. "delve", are still caught per-instance by prohibited-words.)
 const LLM_VOCABULARY = new Set([
     "delve",
     "vibrant",
@@ -14,16 +25,39 @@ const LLM_VOCABULARY = new Set([
     "moreover",
     "tapestry"
 ]);
-const rule = oneToOneRule({
-    detect: (unit) => findVocabularyMatches(unit.text, [...LLM_VOCABULARY]).map((match) => ({
-        evidence: match.text,
-        label: match.text,
-        range: { start: match.start, end: match.end }
-    })),
-    family: "words",
-    formatMessage: (report) => `LLM vocabulary found: "${report.evidence}". Replace the stock diction with a concrete word.`,
-    ruleId: "words:llm-vocabulary",
-    unitKind: "str"
+function vocabularyDetections(unit) {
+    return wordTokens(unit.text)
+        .filter((token) => LLM_VOCABULARY.has(token.normalized) &&
+        !isVocabularyContextAllowed(unit.text, token.normalized))
+        .map((token) => ({
+        evidence: unit.text.slice(token.start, token.end),
+        group: GROUP,
+        label: token.normalized,
+        range: { end: token.end, start: token.start },
+        ruleId: RULE_ID,
+        unitId: unit.id
+    }));
+}
+const rule = defineTextlintRule({
+    detector: {
+        detect: ({ units }) => units.flatMap((unit) => vocabularyDetections(unit)),
+        family: "words",
+        id: RULE_ID
+    },
+    formatMessage: (report) => {
+        const labels = [...new Set(report.detections.map((hit) => hit.label))];
+        return `LLM vocabulary density: ${report.detections.length} stock words in a short span (${labels.join(", ")}). Replace the stock diction with concrete words.`;
+    },
+    reportPolicy: {
+        groups: [GROUP],
+        kind: "density",
+        maxParagraphTokens: MAX_PARAGRAPH_TOKENS,
+        maxWindowTokens: MAX_WINDOW_TOKENS,
+        paragraphMinimumHits: MIN_HITS,
+        windowMinimumHits: MIN_HITS,
+        windowSentences: WINDOW_SENTENCES
+    },
+    units: (document) => paragraphUnits(document)
 });
 export default rule;
 //# sourceMappingURL=llm-vocabulary.js.map

package/dist/rules/words/simplicity.js

@@ -1,26 +1,50 @@
 import simplicityPairs from "./data/simplicity-pairs.json" with { type: "json" };
+import { defineTextlintRule } from "../../adapters/textlint/rule.js";
+import { paragraphUnits } from "../../adapters/textlint/units.js";
 import { wordTokens } from "../../shared/text/tokens.js";
-import { oneToOneRule } from "../private/textlint-rule-builders.js";
-const SIMPLE_BY_COMPLEX = new Map(simplicityPairs.map(([complex, simple]) => [complex, simple]));
-const rule = oneToOneRule({
-    detect: (unit) => wordTokens(unit.text).flatMap((token) => {
-        const simple = SIMPLE_BY_COMPLEX.get(token.normalized);
-        if (simple === undefined) {
-            return [];
-        }
-        return [
-            {
-                data: { simple },
-                evidence: token.text,
-                label: token.text,
-                range: { start: token.start, end: token.end }
-            }
-        ];
-    }),
-    family: "words",
-    formatMessage: (report) => `Complex word found: "${report.evidence}". Use "${report.detections[0]?.data?.["simple"]}" instead.`,
-    ruleId: "words:simplicity",
-    unitKind: "sentence"
+const RULE_ID = "words:simplicity";
+const GROUP = "complex word";
+const MAX_PARAGRAPH_TOKENS = 90;
+const MAX_WINDOW_TOKENS = 65;
+const MIN_HITS = 2;
+const WINDOW_SENTENCES = 4;
+// A single complex word is not slop; one "numerous" or "utilize" is ordinary.
+// Flag only when complex diction clusters, which is what makes prose feel dense.
+const COMPLEX_WORDS = new Set(simplicityPairs
+    .map((pair) => pair[0])
+    .filter((word) => word !== undefined));
+function complexDetections(unit) {
+    return wordTokens(unit.text)
+        .filter((token) => COMPLEX_WORDS.has(token.normalized))
+        .map((token) => ({
+        evidence: unit.text.slice(token.start, token.end),
+        group: GROUP,
+        label: token.normalized,
+        range: { end: token.end, start: token.start },
+        ruleId: RULE_ID,
+        unitId: unit.id
+    }));
+}
+const rule = defineTextlintRule({
+    detector: {
+        detect: ({ units }) => units.flatMap((unit) => complexDetections(unit)),
+        family: "words",
+        id: RULE_ID
+    },
+    formatMessage: (report) => {
+        const labels = [...new Set(report.detections.map((hit) => hit.label))];
+        return `Complex word density: ${report.detections.length} complex words in a short span (${labels.join(", ")}). Prefer simpler wording.`;
+    },
+    reportPolicy: {
+        groups: [GROUP],
+        kind: "density",
+        maxParagraphTokens: MAX_PARAGRAPH_TOKENS,
+        maxWindowTokens: MAX_WINDOW_TOKENS,
+        paragraphMinimumHits: MIN_HITS,
+        windowMinimumHits: MIN_HITS,
+        windowSentences: WINDOW_SENTENCES
+    },
+    units: (document) => paragraphUnits(document)
 });
 export default rule;
 //# sourceMappingURL=simplicity.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",