slopless 0.2.23 → 0.2.25

package/dist/rules/syntactic-patterns/lead-ins/generic-signposting.js

@@ -1,7 +1,12 @@
+import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
+import { paragraphUnits, sentenceUnits } from "../../../adapters/textlint/units.js";
 import { hasConcreteImplementationSummary } from "../../../shared/matchers/concrete-evidence.js";
 import { cleanSentence, containsAny, tokens } from "../../../shared/matchers/prose-patterns.js";
-import { oneToOneRule } from "../../private/textlint-rule-builders.js";
-import { matchDiscourseEvaluationFrame } from "./private/discourse-evaluation.js";
+import { splitSentences } from "../../../shared/text/sentences.js";
+import { matchComponentAssignmentFrame } from "./private/component-assignment-frame.js";
+import { isAbstractAuditFrame, matchReactionFrame, matchDiscourseEvaluationFrame, matchExpandedDiscourseFrame } from "./private/discourse-evaluation.js";
+import { matchEvaluativeColonFrame } from "./private/evaluative-colon-frame.js";
+import { matchRelativeDiscourseFrame } from "./private/relative-discourse-frame.js";
 const PREFIXES = ["however, ", "but ", "and ", "so "];
 // "as such" was removed: it is a normal anaphoric connective ("a registered adviser; as
 // such, it must...") and was the dominant false positive, not a signposting frame.
@@ -47,7 +52,6 @@ const FRAME_PATTERNS = [
     "the useful version is",
     "the point is plain enough"
 ];
-const DETERMINERS = ["a", "an", "the", "this", "that"];
 const SEQUENCE_PATTERNS = [
     "a simple sequence works well",
     "a simple pattern works well",
@@ -88,72 +92,22 @@ const WHAT_FRAME_TAIL_STARTERS = [
     "true",
     "usually"
 ];
-const FRAME_ADJECTIVES = [
-    "basic",
-    "best",
-    "better",
-    "biggest",
-    "bigger",
-    "central",
-    "clearest",
-    "core",
-    "easiest",
-    "final",
-    "first",
-    "hardest",
-    "honest",
-    "important",
-    "main",
-    "only",
-    "obvious",
-    "practical",
-    "real",
-    "simple",
-    "useful"
-];
-const FRAME_NOUNS = [
-    "answer",
-    "approach",
-    "challenge",
-    "choice",
-    "conclusion",
-    "fact",
-    "fix",
-    "focus",
-    "frame",
-    "idea",
-    "lesson",
-    "move",
-    "path",
-    "point",
-    "principle",
-    "priority",
-    "problem",
-    "question",
-    "result",
-    "rule",
-    "shift",
-    "signal",
-    "strategy",
-    "test",
-    "thing",
-    "tradeoff",
-    "truth",
-    "version",
-    "way",
-    "win"
+const WHAT_MATTERS_CLAUSE_STARTERS = [
+    "how",
+    "if",
+    "that",
+    "what",
+    "when",
+    "where",
+    "whether",
+    "which",
+    "who",
+    "whose",
+    "why"
 ];
-const ABSTRACT_FRAME_VERBS = ["is", "are", "was"];
 const POINT_NOUNS = ["goal", "job", "key", "point", "takeaway", "trick"];
 function matchModifiedAbstractFrame(words) {
-    const [first, second, third, fourth, fifth] = words;
-    if (first === "the" &&
-        second === "result" &&
-        third === "worth" &&
-        fourth === "caring" &&
-        fifth === "about") {
-        return "the-result-worth-caring-about";
-    }
+    const [first, second, third, fourth] = words;
     if (first !== "the") {
         return undefined;
     }
@@ -167,20 +121,6 @@ function matchModifiedAbstractFrame(words) {
     ]);
     return matches.get(key);
 }
-function matchEvaluativeFrame(words) {
-    const [first, second, third, fourth] = words;
-    if (first !== undefined &&
-        second !== undefined &&
-        third !== undefined &&
-        fourth !== undefined &&
-        DETERMINERS.includes(first) &&
-        FRAME_ADJECTIVES.includes(second) &&
-        FRAME_NOUNS.includes(third) &&
-        ABSTRACT_FRAME_VERBS.includes(fourth)) {
-        return `the-${second}-${third}-${fourth}`;
-    }
-    return undefined;
-}
 function matchPointIsToFrame(words) {
     const [first, second, third, fourth, fifth] = words;
     if (first === "the" &&
@@ -201,7 +141,8 @@ function matchWhatFrame(words) {
             second === "changes") &&
         third === "is" &&
         fourth !== undefined &&
-        WHAT_FRAME_TAIL_STARTERS.includes(fourth)) {
+        (WHAT_FRAME_TAIL_STARTERS.includes(fourth) ||
+            (second === "matters" && !WHAT_MATTERS_CLAUSE_STARTERS.includes(fourth)))) {
         return `what-${second}-is`;
     }
     if (first === "what" && second === "matters" && third === "most") {
@@ -217,11 +158,13 @@ function matchWhatFrame(words) {
 }
 function matchAbstractFrame(text) {
     const words = tokens(text);
-    return (matchModifiedAbstractFrame(words) ??
-        matchEvaluativeFrame(words) ??
+    return (matchRelativeDiscourseFrame(text, words) ??
+        matchExpandedDiscourseFrame(words) ??
+        matchModifiedAbstractFrame(words) ??
         matchDiscourseEvaluationFrame(words) ??
         matchPointIsToFrame(words) ??
-        matchWhatFrame(words));
+        matchWhatFrame(words) ??
+        matchReactionFrame(words));
 }
 function matchFormulaicContentSetup(text) {
     if (text.startsWith("each ") &&
@@ -266,11 +209,20 @@ function matchGeneratedFormula(text) {
 }
 function matchSignposting(sentence) {
     const stripped = cleanSentence(sentence, PREFIXES);
-    const concreteImplementation = hasConcreteImplementationSummary(stripped);
     const abstract = matchAbstractFrame(stripped);
+    const strippedWords = tokens(stripped);
+    const auditStart = isAbstractAuditFrame(strippedWords)
+        ? stripped.indexOf("audit")
+        : -1;
+    const concreteImplementation = hasConcreteImplementationSummary(abstract !== undefined && auditStart >= 0
+        ? stripped.slice(0, auditStart) + stripped.slice(auditStart + 5)
+        : stripped);
     const formulaicSetup = matchFormulaicContentSetup(stripped);
     const generatedFormula = matchGeneratedFormula(stripped);
-    if (abstract !== undefined && !concreteImplementation) {
+    if (abstract !== undefined &&
+        (abstract === "what-matters-is" ||
+            abstract.startsWith("relative-") ||
+            !concreteImplementation)) {
         return { kind: "abstract-evaluation-frame", signal: abstract };
     }
     if (generatedFormula !== undefined && !concreteImplementation) {
@@ -279,6 +231,9 @@ function matchSignposting(sentence) {
     if (formulaicSetup !== undefined) {
         return { kind: "formulaic-content-setup", signal: formulaicSetup };
     }
+    if (stripped.startsWith("the fun part is:") && !concreteImplementation) {
+        return { kind: "frame-signpost", signal: "the fun part is:" };
+    }
     const checks = [
         ["transition", TRANSITION_PATTERNS],
         ["consultation-signpost", CONSULTATION_PATTERNS],
@@ -302,24 +257,63 @@ function matchSignposting(sentence) {
     }
     return undefined;
 }
-const rule = oneToOneRule({
-    detect: (unit) => {
-        const matched = matchSignposting(unit.text);
-        if (matched === undefined) {
-            return [];
-        }
-        return [
-            {
-                evidence: matched.signal,
-                label: matched.kind,
-                range: { start: 0, end: unit.text.length }
-            }
-        ];
+const rule = defineTextlintRule({
+    detector: {
+        detect: ({ units }) => {
+            const detections = units.flatMap((unit) => {
+                if (unit.kind === "paragraph") {
+                    const sentences = splitSentences(unit.text);
+                    const pairDetections = [];
+                    for (let index = 0; index < sentences.length - 1; index += 1) {
+                        const current = sentences[index];
+                        const next = sentences[index + 1];
+                        if (current === undefined || next === undefined) {
+                            continue;
+                        }
+                        const signal = matchComponentAssignmentFrame(current.text, next.text);
+                        if (signal !== undefined) {
+                            pairDetections.push({
+                                evidence: signal,
+                                label: "component-assignment-frame",
+                                range: { start: current.start, end: next.end },
+                                ruleId: "syntactic-patterns:generic-signposting",
+                                unitId: unit.id
+                            });
+                        }
+                    }
+                    return pairDetections;
+                }
+                const componentSignal = matchComponentAssignmentFrame(unit.text);
+                const colonSignal = matchEvaluativeColonFrame(unit.text);
+                const matched = componentSignal === undefined && colonSignal === undefined
+                    ? matchSignposting(unit.text)
+                    : undefined;
+                const signal = componentSignal ?? colonSignal ?? matched?.signal;
+                if (signal === undefined) {
+                    return [];
+                }
+                return [
+                    {
+                        evidence: signal,
+                        label: componentSignal !== undefined
+                            ? "component-assignment-frame"
+                            : colonSignal !== undefined
+                                ? "evaluative-colon-frame"
+                                : (matched?.kind ?? "generic-signposting"),
+                        range: { start: 0, end: unit.text.length },
+                        ruleId: "syntactic-patterns:generic-signposting",
+                        unitId: unit.id
+                    }
+                ];
+            });
+            return detections;
+        },
+        family: "syntactic-patterns",
+        id: "syntactic-patterns:generic-signposting"
     },
-    family: "syntactic-patterns",
     formatMessage: (report) => `Generic signposting found: ${report.evidence}. Replace the frame with the concrete claim.`,
-    ruleId: "syntactic-patterns:generic-signposting",
-    unitKind: "sentence"
+    reportPolicy: { kind: "one-to-one" },
+    units: (document) => [...sentenceUnits(document), ...paragraphUnits(document)]
 });
 export default rule;
 //# sourceMappingURL=generic-signposting.js.map

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,4 +1,75 @@
+export { matchReactionFrame } from "./reaction-frame.js";
 const ABSTRACT_FRAME_VERBS = ["is", "are", "was", "were"];
+const DISCOURSE_WORK_TAILS = [
+    ["doing", "real", "work"],
+    ["load", "bearing"]
+];
+const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const FRAME_ADJECTIVES = new Set([
+    "basic",
+    "best",
+    "better",
+    "biggest",
+    "bigger",
+    "central",
+    "clearest",
+    "core",
+    "easiest",
+    "final",
+    "first",
+    "hardest",
+    "honest",
+    "important",
+    "main",
+    "only",
+    "obvious",
+    "practical",
+    "real",
+    "simple",
+    "useful"
+]);
+const FRAME_NOUNS = new Set([
+    "answer",
+    "approach",
+    "audit",
+    "challenge",
+    "choice",
+    "conclusion",
+    "diagnosis",
+    "fact",
+    "fix",
+    "focus",
+    "frame",
+    "idea",
+    "lesson",
+    "move",
+    "path",
+    "point",
+    "principle",
+    "priority",
+    "problem",
+    "question",
+    "result",
+    "rule",
+    "shift",
+    "signal",
+    "strategy",
+    "test",
+    "thing",
+    "tradeoff",
+    "truth",
+    "version",
+    "way",
+    "win"
+]);
+const VAGUE_FRAME_VERBS = new Set(["begins", "happens", "lives", "starts"]);
+const VAGUE_FRAME_LOCATIONS = new Set([
+    "downstream",
+    "earlier",
+    "here",
+    "there",
+    "upstream"
+]);
 const EVALUATION_TAILS = new Set([
     "boring",
     "clear",
@@ -72,15 +143,90 @@ function isDiscourseEvaluationSubject(first, subject) {
     }
     return subject.some((word) => DISCOURSE_SUBJECT_HEADS.has(word));
 }
-export function matchDiscourseEvaluationFrame(words) {
-    const [first] = words;
-    if (words.length > 8 ||
-        !["the", "this", "that", "it"].includes(first ?? "")) {
+function matchDiscourseWorkClaim(words, verbIndex, subject) {
+    if (verbIndex <= 0 ||
+        words[verbIndex] !== "is" ||
+        !DISCOURSE_SUBJECT_HEADS.has(subject.at(-1) ?? "")) {
+        return undefined;
+    }
+    const tail = DISCOURSE_WORK_TAILS.find((candidate) => candidate.every((word, index) => words[verbIndex + index + 1] === word));
+    return tail === undefined ? undefined : `is-${tail.join("-")}`;
+}
+function frameNounIndex(words) {
+    if (FRAME_NOUNS.has(words[1] ?? "")) {
+        return 1;
+    }
+    return FRAME_ADJECTIVES.has(words[1] ?? "") && FRAME_NOUNS.has(words[2] ?? "")
+        ? 2
+        : -1;
+}
+function matchWorthAttentionFrame(words) {
+    if (words[0] !== "the") {
         return undefined;
     }
+    const nounIndex = frameNounIndex(words);
+    if (nounIndex < 0 || words[nounIndex + 1] !== "worth") {
+        return undefined;
+    }
+    const tail = words.slice(nounIndex + 2);
+    const matches = tail[0] === "noticing" ||
+        tail[0] === "watching" ||
+        tail[0] === "tracking" ||
+        (tail[0] === "caring" && tail[1] === "about") ||
+        (tail[0] === "paying" && tail[1] === "attention" && tail[2] === "to");
+    return matches
+        ? `the-${words.slice(1, nounIndex + 1).join("-")}-worth-attention`
+        : undefined;
+}
+function matchVagueFrameLocation(words) {
+    const [first, adjective, noun, verb, location] = words;
+    return words.length === 5 &&
+        first === "the" &&
+        FRAME_ADJECTIVES.has(adjective ?? "") &&
+        FRAME_NOUNS.has(noun ?? "") &&
+        VAGUE_FRAME_VERBS.has(verb ?? "") &&
+        VAGUE_FRAME_LOCATIONS.has(location ?? "")
+        ? `the-${adjective ?? "useful"}-${noun ?? "frame"}-${verb ?? "starts"}-${location ?? "here"}`
+        : undefined;
+}
+function matchEvaluativeFrame(words) {
+    const [first, adjective, noun, verb] = words;
+    return first !== undefined &&
+        adjective !== undefined &&
+        noun !== undefined &&
+        verb !== undefined &&
+        DETERMINERS.has(first) &&
+        FRAME_ADJECTIVES.has(adjective) &&
+        FRAME_NOUNS.has(noun) &&
+        ["is", "are", "was"].includes(verb)
+        ? `the-${adjective}-${noun}-${verb}`
+        : undefined;
+}
+export function isAbstractAuditFrame(words) {
+    return words[0] === "the" && frameNounIndex(words) > 0
+        ? words[frameNounIndex(words)] === "audit"
+        : false;
+}
+export function matchExpandedDiscourseFrame(words) {
+    return (matchWorthAttentionFrame(words) ??
+        matchVagueFrameLocation(words) ??
+        matchEvaluativeFrame(words));
+}
+export function matchDiscourseEvaluationFrame(words) {
+    const [first] = words;
     const verbIndex = words.findIndex((word) => ABSTRACT_FRAME_VERBS.includes(word));
     const tail = words.at(-1);
     const subject = verbIndex > 0 ? words.slice(0, verbIndex) : [];
+    const workClaim = matchDiscourseWorkClaim(words, verbIndex, subject);
+    if (workClaim !== undefined) {
+        return workClaim;
+    }
+    if (words.length > 8) {
+        return undefined;
+    }
+    if (!["the", "this", "that", "it"].includes(first ?? "")) {
+        return undefined;
+    }
     return verbIndex > 0 &&
         tail !== undefined &&
         EVALUATION_TAILS.has(tail) &&