slopless 0.2.15 → 0.2.17

package/dist/presets/everything.js

@@ -3,7 +3,6 @@ export const everything = {
         "affirmation-closers": true,
         "artifact-placeholders": true,
         "authority-padding": true,
-        "avg-sentence-length": true,
         "blame-reframe": true,
         "body-action-density": true,
         "boilerplate-conclusion": true,

package/dist/registries/metrics.js

@@ -1,11 +1,9 @@
-import avgSentenceLength from "../rules/metrics/avg-sentence-length.js";
 import colemanLiau from "../rules/metrics/coleman-liau.js";
 import fleschKincaid from "../rules/metrics/flesch-kincaid.js";
 import gunningFog from "../rules/metrics/gunning-fog.js";
 import paragraphLength from "../rules/metrics/paragraph-length.js";
 import wordRepetition from "../rules/metrics/word-repetition.js";
 export const metricRules = {
-    "avg-sentence-length": avgSentenceLength,
     "coleman-liau": colemanLiau,
     "flesch-kincaid": fleschKincaid,
     "gunning-fog": gunningFog,

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/dist/shared/text/document.js

@@ -1,18 +1,8 @@
 import { allParagraphs } from "./sections.js";
-import { splitSentences } from "./sentences.js";
-import { wordTokens } from "./tokens.js";
 export function documentText(document) {
     return allParagraphs(document)
         .map((paragraph) => paragraph.text.trim())
         .filter((text) => text.length > 0)
         .join("\n\n");
 }
-export function documentMetrics(document) {
-    const text = documentText(document);
-    return {
-        sentenceCount: splitSentences(text).length,
-        text,
-        wordCount: wordTokens(text).length
-    };
-}
 //# sourceMappingURL=document.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",
@@ -52,7 +52,6 @@
     "./rules/academic-slop/academic-boilerplate": "./dist/rules/academic-slop/academic-boilerplate.js",
     "./rules/academic-slop/academic-formula-frames": "./dist/rules/academic-slop/academic-formula-frames.js",
     "./rules/academic-slop/tortured-phrases": "./dist/rules/academic-slop/tortured-phrases.js",
-    "./rules/metrics/avg-sentence-length": "./dist/rules/metrics/avg-sentence-length.js",
     "./rules/metrics/coleman-liau": "./dist/rules/metrics/coleman-liau.js",
     "./rules/metrics/flesch-kincaid": "./dist/rules/metrics/flesch-kincaid.js",
     "./rules/metrics/gunning-fog": "./dist/rules/metrics/gunning-fog.js",

package/dist/rules/metrics/avg-sentence-length.js

@@ -1,34 +0,0 @@
-import { documentMetrics } from "../../shared/text/document.js";
-import { oneToOneRule } from "../private/textlint-rule-builders.js";
-const MAX_WORDS = 24;
-function isDocumentNode(node) {
-    return node.type === "Document" && "children" in node;
-}
-const rule = oneToOneRule({
-    detect: (unit) => {
-        if (!isDocumentNode(unit.node)) {
-            return [];
-        }
-        const metrics = documentMetrics(unit.node);
-        if (metrics.sentenceCount === 0) {
-            return [];
-        }
-        const average = Math.floor(metrics.wordCount / metrics.sentenceCount);
-        if (average <= MAX_WORDS) {
-            return [];
-        }
-        return [
-            {
-                evidence: String(average),
-                label: "average sentence length",
-                range: { start: 0, end: 0 }
-            }
-        ];
-    },
-    family: "metrics",
-    formatMessage: (report) => `Average sentence length is ${report.evidence} words. Keep it at ${MAX_WORDS} or fewer.`,
-    ruleId: "metrics:avg-sentence-length",
-    unitKind: "document"
-});
-export default rule;
-//# sourceMappingURL=avg-sentence-length.js.map