slopless 0.2.24 → 0.2.26

package/dist/rules/syntactic-patterns/lead-ins/private/component-assignment-frame.js

@@ -0,0 +1,239 @@
+import { tokens } from "../../../../shared/matchers/prose-patterns.js";
+import { normalizeForMatch } from "../../../../shared/text/normalize.js";
+const COPULAS = new Set(["are", "is", "was", "were"]);
+const DETERMINERS = new Set(["a", "an", "the"]);
+const ACTOR_ROLES = new Set([
+    "agent",
+    "analyst",
+    "author",
+    "creator",
+    "editor",
+    "model",
+    "producer",
+    "researcher",
+    "writer"
+]);
+const WRITING_ROLES = new Set([
+    "author",
+    "creator",
+    "editor",
+    "producer",
+    "writer"
+]);
+const COMPONENT_HEADS = new Set([
+    "basis",
+    "context",
+    "goal",
+    "input",
+    "material",
+    "output",
+    "source"
+]);
+const WRITING_MATERIALS = new Set([
+    "article",
+    "brief",
+    "content",
+    "copy",
+    "draft",
+    "evidence",
+    "findings",
+    "interviews",
+    "notes",
+    "recommendation",
+    "report",
+    "research",
+    "transcript"
+]);
+const EXPLANATION_WORDS = new Set([
+    "although",
+    "because",
+    "if",
+    "since",
+    "so",
+    "therefore",
+    "unless",
+    "when",
+    "where",
+    "which",
+    "while",
+    "who"
+]);
+const DETAIL_PREPOSITIONS = new Set([
+    "after",
+    "at",
+    "before",
+    "by",
+    "from",
+    "in",
+    "into",
+    "of",
+    "on",
+    "through",
+    "to",
+    "under",
+    "with"
+]);
+const TECHNICAL_LABELS = new Set([
+    "array",
+    "bytes",
+    "classifier",
+    "csv",
+    "event",
+    "file",
+    "image",
+    "interface",
+    "json",
+    "object",
+    "request",
+    "response",
+    "schema",
+    "service",
+    "string",
+    "tensor",
+    "vector"
+]);
+function withoutDeterminer(words) {
+    return DETERMINERS.has(words[0] ?? "") ? words.slice(1) : words;
+}
+function trimTerminalPunctuation(text) {
+    let end = text.length;
+    while (end > 0 && [".", "!", "?"].includes(text[end - 1] ?? "")) {
+        end -= 1;
+    }
+    return text.slice(0, end);
+}
+function hasTechnicalSyntax(text) {
+    const blockedCharacters = new Set([
+        "`",
+        "(",
+        ")",
+        "[",
+        "]",
+        "{",
+        "}",
+        "=",
+        "<",
+        ">",
+        "/",
+        "\\"
+    ]);
+    for (const character of text) {
+        if (blockedCharacters.has(character) ||
+            (character >= "0" && character <= "9")) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseNormalizedAssignment(normalized) {
+    if (normalized.length === 0 || hasTechnicalSyntax(normalized)) {
+        return undefined;
+    }
+    const words = tokens(normalized);
+    const copulaIndex = words.findIndex((word) => COPULAS.has(word));
+    if (copulaIndex < 1 ||
+        copulaIndex > 3 ||
+        words.length - copulaIndex - 1 < 1 ||
+        words.length - copulaIndex - 1 > 4) {
+        return undefined;
+    }
+    const subject = withoutDeterminer(words.slice(0, copulaIndex));
+    const complement = withoutDeterminer(words.slice(copulaIndex + 1));
+    const blocked = [...subject, ...complement].some((word) => EXPLANATION_WORDS.has(word) || DETAIL_PREPOSITIONS.has(word));
+    return subject.length === 0 || complement.length === 0 || blocked
+        ? undefined
+        : { complement, subject };
+}
+function assignmentClauseCandidates(clause) {
+    const normalized = trimTerminalPunctuation(normalizeForMatch(clause));
+    const candidates = [normalized];
+    const delimiterIndexes = [
+        normalized.indexOf(","),
+        normalized.indexOf(";"),
+        normalized.indexOf(" - "),
+        normalized.indexOf(" \u2013 "),
+        normalized.indexOf(" \u2014 ")
+    ].filter((index) => index > 0);
+    const firstDelimiter = Math.min(...delimiterIndexes);
+    if (Number.isFinite(firstDelimiter)) {
+        candidates.push(normalized.slice(0, firstDelimiter).trim());
+    }
+    return candidates;
+}
+function parseAssignment(clause) {
+    for (const candidate of assignmentClauseCandidates(clause)) {
+        const assignment = parseNormalizedAssignment(candidate);
+        if (assignment !== undefined) {
+            return assignment;
+        }
+    }
+    return undefined;
+}
+function isActorAssignment(assignment) {
+    const subjectHead = assignment.subject.at(-1) ?? "";
+    const complementHead = assignment.complement.at(-1) ?? "";
+    return ACTOR_ROLES.has(subjectHead) && ACTOR_ROLES.has(complementHead);
+}
+function isComponentAssignment(assignment) {
+    const subjectHead = assignment.subject.at(-1) ?? "";
+    return COMPONENT_HEADS.has(subjectHead);
+}
+function hasWritingContext(actor, component) {
+    const actorWords = [...actor.subject, ...actor.complement];
+    const componentHead = component.complement.at(-1) ?? "";
+    return (actorWords.some((word) => WRITING_ROLES.has(word)) ||
+        WRITING_MATERIALS.has(componentHead));
+}
+function isTechnicalInterface(actor, component) {
+    return [...actor.complement, ...component.complement].some((word) => TECHNICAL_LABELS.has(word));
+}
+function splitClauses(text) {
+    const normalized = normalizeForMatch(text);
+    const separators = [];
+    for (let index = 0; index < normalized.length; index += 1) {
+        const character = normalized[index] ?? "";
+        const isPunctuationSeparator = character === "," || character === ";";
+        const isSpacedDash = ["-", "\u2013", "\u2014"].includes(character) &&
+            (normalized[index - 1] ?? "").trim() === "" &&
+            (normalized[index + 1] ?? "").trim() === "";
+        if (isPunctuationSeparator || isSpacedDash) {
+            separators.push(index);
+        }
+    }
+    if (separators.length !== 1) {
+        return undefined;
+    }
+    const separator = separators[0] ?? -1;
+    const first = normalized.slice(0, separator).trim();
+    const second = normalized.slice(separator + 1).trim();
+    return first.length > 0 && second.length > 0 ? [first, second] : undefined;
+}
+export function matchComponentAssignmentFrame(first, second) {
+    const pair = second === undefined ? splitClauses(first) : [first, second];
+    if (pair === undefined) {
+        return undefined;
+    }
+    const firstAssignment = parseAssignment(pair[0]);
+    const secondAssignment = parseAssignment(pair[1]);
+    if (firstAssignment === undefined || secondAssignment === undefined) {
+        return undefined;
+    }
+    const actor = isActorAssignment(firstAssignment)
+        ? firstAssignment
+        : isActorAssignment(secondAssignment)
+            ? secondAssignment
+            : undefined;
+    const component = isComponentAssignment(firstAssignment)
+        ? firstAssignment
+        : isComponentAssignment(secondAssignment)
+            ? secondAssignment
+            : undefined;
+    return actor !== undefined &&
+        component !== undefined &&
+        actor !== component &&
+        hasWritingContext(actor, component) &&
+        !isTechnicalInterface(actor, component)
+        ? "component-assignment-frame"
+        : undefined;
+}
+//# sourceMappingURL=component-assignment-frame.js.map

package/dist/rules/syntactic-patterns/lead-ins/private/discourse-evaluation.js

@@ -1,3 +1,4 @@
+export { matchReactionFrame } from "./reaction-frame.js";
 const ABSTRACT_FRAME_VERBS = ["is", "are", "was", "were"];
 const DISCOURSE_WORK_TAILS = [
     ["doing", "real", "work"],

package/dist/rules/syntactic-patterns/lead-ins/private/evaluative-colon-frame.js

@@ -0,0 +1,166 @@
+import { hasConcreteTechnicalToken } from "../../../../shared/matchers/concrete-evidence.js";
+import { tokens } from "../../../../shared/matchers/prose-patterns.js";
+import { normalizeForMatch } from "../../../../shared/text/normalize.js";
+const SUBJECT_HEADS = new Set([
+    "answer",
+    "answers",
+    "approach",
+    "approaches",
+    "architecture",
+    "architectures",
+    "audit",
+    "audits",
+    "choice",
+    "choices",
+    "decision",
+    "decisions",
+    "design",
+    "designs",
+    "machine",
+    "machines",
+    "method",
+    "methods",
+    "model",
+    "models",
+    "pipeline",
+    "pipelines",
+    "plan",
+    "plans",
+    "platform",
+    "platforms",
+    "problem",
+    "problems",
+    "process",
+    "processes",
+    "solution",
+    "solutions",
+    "stack",
+    "stacks",
+    "strategy",
+    "strategies",
+    "setup",
+    "setups",
+    "system",
+    "systems",
+    "workflow",
+    "workflows"
+]);
+const EVALUATIVE_ADJECTIVES = new Set([
+    "boring",
+    "clear",
+    "complex",
+    "easy",
+    "hard",
+    "heavy",
+    "obvious",
+    "simple",
+    "straightforward"
+]);
+const EVALUATIVE_LINKS = new Set([
+    "are",
+    "feel",
+    "feels",
+    "is",
+    "look",
+    "looks",
+    "was",
+    "were"
+]);
+const QUANTITY_WORDS = new Set([
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "dozen",
+    "hundred",
+    "thousand",
+    "million",
+    "several"
+]);
+const MONTHS_AND_TIMES = new Set([
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+    "midnight",
+    "noon"
+]);
+function hasDigitOrEquationSymbol(text) {
+    for (const character of text) {
+        if ((character >= "0" && character <= "9") ||
+            ["=", "<", ">", "+", "\u00d7", "\u00f7"].includes(character)) {
+            return true;
+        }
+    }
+    return false;
+}
+function firstAsciiWord(text) {
+    let word = "";
+    for (const character of text.trimStart()) {
+        const isLetter = (character >= "A" && character <= "Z") ||
+            (character >= "a" && character <= "z");
+        const isWordContinuation = isLetter || (character >= "0" && character <= "9") || character === "-";
+        if (!isWordContinuation) {
+            break;
+        }
+        word += character;
+    }
+    return word.length > 0 ? word : undefined;
+}
+function isIdentifierLike(word) {
+    for (const character of word.slice(1)) {
+        if (character >= "A" && character <= "Z") {
+            return true;
+        }
+    }
+    return false;
+}
+function hasExcludedEvidence(text, words) {
+    const trimmed = text.trimStart();
+    const firstWord = firstAsciiWord(trimmed);
+    const startsWithNamedTechnicalSubject = firstWord !== undefined &&
+        isIdentifierLike(firstWord) &&
+        hasConcreteTechnicalToken(text);
+    return (hasDigitOrEquationSymbol(text) ||
+        trimmed.startsWith('"') ||
+        trimmed.startsWith("'") ||
+        text.includes("`") ||
+        startsWithNamedTechnicalSubject ||
+        words.some((word) => QUANTITY_WORDS.has(word) || MONTHS_AND_TIMES.has(word)));
+}
+export function matchEvaluativeColonFrame(text) {
+    const colonIndex = text.indexOf(":");
+    if (colonIndex < 0 || text.indexOf(":", colonIndex + 1) >= 0) {
+        return undefined;
+    }
+    const prefix = normalizeForMatch(text.slice(0, colonIndex));
+    const detail = text.slice(colonIndex + 1);
+    const prefixWords = tokens(prefix);
+    const detailWords = tokens(detail);
+    const copulaIndex = prefixWords.findIndex((word) => EVALUATIVE_LINKS.has(word));
+    if (copulaIndex < 1 ||
+        copulaIndex > 3 ||
+        prefixWords.length !== copulaIndex + 2 ||
+        !SUBJECT_HEADS.has(prefixWords[copulaIndex - 1] ?? "") ||
+        !EVALUATIVE_ADJECTIVES.has(prefixWords[copulaIndex + 1] ?? "") ||
+        detailWords.length < 2 ||
+        hasExcludedEvidence(detail, detailWords)) {
+        return undefined;
+    }
+    return prefixWords.join("-");
+}
+//# sourceMappingURL=evaluative-colon-frame.js.map

package/dist/rules/syntactic-patterns/lead-ins/private/reaction-frame.js

@@ -0,0 +1,29 @@
+const REACTION_NOUNS = new Set(["detail", "part", "piece", "point", "thing"]);
+const REACTION_VERBS = new Set(["got", "hit", "stuck", "surprised"]);
+export function matchReactionFrame(words) {
+    const contracted = words[0] === "here's";
+    const start = contracted || (words[0] === "here" && words[1] === "is")
+        ? contracted
+            ? 1
+            : 2
+        : -1;
+    if (start < 0 ||
+        words[start] !== "the" ||
+        !REACTION_NOUNS.has(words[start + 1] ?? "") ||
+        words[start + 2] !== "that") {
+        return undefined;
+    }
+    const verb = words[start + 3];
+    const directReaction = verb !== "stuck" &&
+        REACTION_VERBS.has(verb ?? "") &&
+        ["me", "us"].includes(words[start + 4] ?? "") &&
+        words.length === start + 5;
+    const stuckReaction = verb === "stuck" &&
+        words[start + 4] === "with" &&
+        ["me", "us"].includes(words[start + 5] ?? "") &&
+        words.length === start + 6;
+    return directReaction || stuckReaction
+        ? "here-is-the-reaction-frame"
+        : undefined;
+}
+//# sourceMappingURL=reaction-frame.js.map

package/dist/rules/syntactic-patterns/lead-ins/private/relative-discourse-frame.js

@@ -0,0 +1,119 @@
+import { tokens } from "../../../../shared/matchers/prose-patterns.js";
+const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const RELATIVE_FRAME_MODIFIERS = new Set([
+    "central",
+    "clearest",
+    "core",
+    "important",
+    "main",
+    "practical",
+    "real",
+    "simple",
+    "useful"
+]);
+const RELATIVE_HELPER_VERBS = new Set([
+    "helped",
+    "helps",
+    "mattered",
+    "matters",
+    "worked",
+    "works"
+]);
+const RELATIVE_USEFULNESS_ADJECTIVES = new Set([
+    "actionable",
+    "better",
+    "clear",
+    "easier",
+    "effective",
+    "helpful",
+    "practical",
+    "reliable",
+    "useful",
+    "valuable"
+]);
+const RELATIVE_EVALUATIONS = new Set([
+    "clear",
+    "consistent",
+    "predictable",
+    "repeatable",
+    "simple",
+    "straightforward",
+    "useful"
+]);
+const RELATIVE_FRAME_HEADS = new Set([
+    "answer",
+    "approach",
+    "claim",
+    "detail",
+    "evidence",
+    "factor",
+    "feature",
+    "fix",
+    "focus",
+    "idea",
+    "lesson",
+    "method",
+    "move",
+    "plan",
+    "point",
+    "process",
+    "question",
+    "result",
+    "review",
+    "rule",
+    "signal",
+    "solution",
+    "step",
+    "strategy",
+    "thing",
+    "way"
+]);
+function relativeFrameHeadIndex(words) {
+    if (!DETERMINERS.has(words[0] ?? "")) {
+        return -1;
+    }
+    if (RELATIVE_FRAME_HEADS.has(words[1] ?? "")) {
+        return 1;
+    }
+    return RELATIVE_FRAME_MODIFIERS.has(words[1] ?? "") &&
+        RELATIVE_FRAME_HEADS.has(words[2] ?? "")
+        ? 2
+        : -1;
+}
+function matchRelativeHelperFrame(text, words, headIndex) {
+    const helperIndex = headIndex + 2;
+    const colonIndex = text.indexOf(":");
+    if (words[headIndex + 1] !== "that" ||
+        !RELATIVE_HELPER_VERBS.has(words[helperIndex] ?? "") ||
+        colonIndex < 0 ||
+        tokens(text.slice(0, colonIndex)).length !== helperIndex + 1) {
+        return undefined;
+    }
+    return `relative-${words[helperIndex] ?? "helps"}-frame`;
+}
+function matchRelativeUsefulnessFrame(words, headIndex) {
+    const makesIndex = headIndex + 2;
+    if (words[headIndex + 1] !== "that" ||
+        !["made", "makes"].includes(words[makesIndex] ?? "")) {
+        return undefined;
+    }
+    const usefulnessIndex = words.findIndex((word, index) => index > makesIndex + 1 &&
+        index <= makesIndex + 6 &&
+        RELATIVE_USEFULNESS_ADJECTIVES.has(word));
+    const evaluationIndex = usefulnessIndex + 2;
+    return usefulnessIndex > 0 &&
+        ["are", "is", "was", "were"].includes(words[usefulnessIndex + 1] ?? "") &&
+        RELATIVE_EVALUATIONS.has(words[evaluationIndex] ?? "") &&
+        words.length === evaluationIndex + 1
+        ? "relative-makes-useful-evaluation"
+        : undefined;
+}
+export function matchRelativeDiscourseFrame(text, words) {
+    const headIndex = relativeFrameHeadIndex(words);
+    if (headIndex < 0) {
+        return undefined;
+    }
+    return (matchRelativeHelperFrame(text, words, headIndex) ??
+        matchRelativeUsefulnessFrame(words, headIndex));
+}
+//# sourceMappingURL=relative-discourse-frame.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",
@@ -19,18 +19,18 @@
     "cli"
   ],
   "license": "MIT",
-  "author": "seochecks.ai (https://seochecks.ai)",
+  "author": "berelevant.ai (https://berelevant.ai)",
   "publishConfig": {
     "access": "public",
     "provenance": true
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/seochecks-ai/slopless.git"
+    "url": "git+https://github.com/berelevant-ai/slopless.git"
   },
-  "homepage": "https://github.com/seochecks-ai/slopless#readme",
+  "homepage": "https://github.com/berelevant-ai/slopless#readme",
   "bugs": {
-    "url": "https://github.com/seochecks-ai/slopless/issues"
+    "url": "https://github.com/berelevant-ai/slopless/issues"
   },
   "type": "module",
   "main": "./dist/index.js",