slopless 0.2.24 → 0.2.25

package/dist/rules/semantic-thinness/patterns/abstract-metaphor-claim.json

@@ -17,7 +17,39 @@
         "{abstractSubject} {linkingVerb} {infrastructureNoun} with {abstractObject}.",
         "{abstractSubject} behaves like a {filterNoun}.",
         "{artifactSubject} adds another {layerNoun} to {diagnosisObject}.",
-        "{artifactSubject} add another {layerNoun} to {diagnosisObject}."
+        "{artifactSubject} add another {layerNoun} to {diagnosisObject}.",
+        {
+            "text": "{identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "the {identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{identityArtifact} {linkingVerb} the {artifactRole} now.",
+            "matchMode": "full"
+        },
+        {
+            "text": "the {identityArtifact} {linkingVerb} the {artifactRole} now.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{audiencePreposition} the {automatedAudience}, the {identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{audiencePreposition} the {automatedAudience}, {identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{audiencePreposition} the {automatedAudience} {audienceActivity}, the {identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{audiencePreposition} the {automatedAudience} {audienceActivity}, {identityArtifact} {linkingVerb} the {artifactRole}.",
+            "matchMode": "full"
+        }
     ],
     "slots": {
         "abstractSubject": [
@@ -87,6 +119,56 @@
             "the report",
             "visibility"
         ],
+        "identityArtifact": [
+            "feed",
+            "page",
+            "prompt",
+            "dashboard",
+            "database",
+            "index",
+            "schema",
+            "metadata",
+            "report",
+            "spreadsheet",
+            "interface",
+            "pipeline",
+            "model",
+            "content"
+        ],
+        "artifactRole": [
+            "product",
+            "strategy",
+            "decision",
+            "answer",
+            "business",
+            "brand",
+            "storefront",
+            "market",
+            "distribution",
+            "experience",
+            "work",
+            "source of truth"
+        ],
+        "audiencePreposition": ["for", "to"],
+        "automatedAudience": [
+            "agent",
+            "ai assistant",
+            "algorithm",
+            "assistant",
+            "crawler",
+            "machine",
+            "model",
+            "ranking system",
+            "recommendation engine",
+            "search agent"
+        ],
+        "audienceActivity": [
+            "choosing the product",
+            "doing the shopping",
+            "making the decision",
+            "ranking the results",
+            "reading the page"
+        ],
         "abstractObject": [
             "consequences",
             "diagnosis",

package/dist/rules/semantic-thinness/patterns/deictic-summary.json

@@ -5,8 +5,26 @@
     "matchMode": "contains",
     "maxTokens": 80,
     "templates": [
-        "{deicticSubject} {linkingVerb} the {summaryNoun}.",
-        "{deicticSubject} {linkingVerb} the {evaluativeAdjective} {summaryNoun}.",
+        {
+            "text": "{deicticCopula} the {summaryNoun}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{deicticCopula} the {evaluativeAdjective} {summaryNoun}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{deicticSubject} {linkingVerb} the {summaryNoun}.",
+            "matchMode": "full"
+        },
+        {
+            "text": "{deicticSubject} {linkingVerb} the {summaryNoun}.",
+            "matchMode": "connector"
+        },
+        {
+            "text": "{deicticSubject} {linkingVerb} the {evaluativeAdjective} {summaryNoun}.",
+            "matchMode": "full"
+        },
         "{deicticSubject} {linkingVerb} the {summaryNoun} that {thinPredicate}.",
         "{deicticSubject} {linkingVerb} the {summaryNoun} {genericAudience} {reactionVerb}.",
         "{deicticSubject} {summaryVerb} the {summaryNoun}.",
@@ -14,6 +32,7 @@
         "{deicticSubject} {meaningVerb} {summaryNoun}.",
         "{deicticSubject} {explanationVerb} {summaryNoun}.",
         "{deicticSubject} {explanationVerb} the {summaryNoun}.",
+        "{deicticSubject} {speechVerb} {deicticSubject} {linkingVerb} the {summaryNoun}.",
         "{deicticSubject} {meaningVerb} {abstractSubject} {linkingVerb} {weakJudgment}.",
         "{deicticSubject} {explanationVerb} why {abstractSubject} {abstractVerb}.",
         "{deicticSubject} {explanationVerb} how {abstractSubject} {abstractVerb}.",
@@ -30,6 +49,14 @@
         "{deicticSubject} {linkingVerb} the reason {abstractSubject} {importanceVerb}."
     ],
     "slots": {
+        "deicticCopula": [
+            "that is",
+            "this is",
+            "it is",
+            "that's",
+            "this's",
+            "it's"
+        ],
         "deicticSubject": ["that", "this", "it"],
         "linkingVerb": ["is", "was"],
         "evaluativeAdjective": [
@@ -51,6 +78,7 @@
         ],
         "summaryNoun": [
             "part",
+            "piece",
             "promise",
             "truth",
             "lesson",
@@ -99,6 +127,7 @@
         ],
         "meaningVerb": ["means", "meant", "does not mean", "doesn't mean"],
         "explanationVerb": ["shows", "showed", "explains", "explained", "proves"],
+        "speechVerb": ["says", "said", "tells", "told"],
         "weakJudgment": [
             "useless",
             "useful",

package/dist/rules/semantic-thinness/patterns/empty-scene-transition.json

@@ -2,11 +2,12 @@
     "id": "empty-scene-transition",
     "class": "transition-change",
     "purpose": "Catch generic transition lines that declare change, passage, or motion without naming what changed or why.",
-    "matchMode": "contains",
+    "matchMode": "full",
     "templates": [
         "{genericSubject} {changeVerb}.",
         "{genericSubject} {changeVerb} {weakModifier}.",
         "{genericSubject} {changeVerb} {genericObject}.",
+        "{weakModifier}, {genericSubject} {changeVerb}.",
         "{genericSubject} {passageVerb}."
     ],
     "slots": {

package/dist/rules/semantic-thinness/private/concrete-guards.js

@@ -1,6 +1,7 @@
 const CONCRETE_EXPLANATION_TOKENS = new Set([
     "api",
     "archive",
+    "assigned",
     "auditor",
     "billing",
     "bids",
@@ -20,6 +21,7 @@ const CONCRETE_EXPLANATION_TOKENS = new Set([
     "invoice",
     "key",
     "ledger",
+    "lists",
     "masonry",
     "mark",
     "meter",

package/dist/rules/semantic-thinness/private/pattern-matcher.js

@@ -16,6 +16,7 @@ const REJECT_TOKENS = new Set([
 ]);
 const BROAD_PATTERN_IDS = new Set([
     "abstract-agency-personification",
+    "abstract-metaphor-claim",
     "abstract-personification-line",
     "body-emotion-shorthand",
     "deictic-summary",
@@ -59,15 +60,16 @@ function readSlotName(template, start) {
     return [name, index];
 }
 function compileTemplate(template) {
+    const text = typeof template === "string" ? template : template.text;
     const parts = [];
     let literal = "";
     let index = 0;
-    while (index < template.length) {
-        const character = template[index];
+    while (index < text.length) {
+        const character = text[index];
         if (character === "{") {
             flushLiteral(parts, literal);
             literal = "";
-            const [name, nextIndex] = readSlotName(template, index);
+            const [name, nextIndex] = readSlotName(text, index);
             parts.push({ kind: "slot", name });
             index = nextIndex;
             continue;
@@ -76,7 +78,16 @@ function compileTemplate(template) {
         index += 1;
     }
     flushLiteral(parts, literal);
-    return { parts, signal: template };
+    const matchMode = typeof template !== "string" &&
+        (template.matchMode === "contains" ||
+            template.matchMode === "connector" ||
+            template.matchMode === "full" ||
+            template.matchMode === "suffix")
+        ? template.matchMode
+        : undefined;
+    return matchMode === undefined
+        ? { parts, signal: text }
+        : { matchMode, parts, signal: text };
 }
 function compileSlotValues(slots) {
     const compiled = {};
@@ -138,6 +149,7 @@ function matchPart(source, pattern, part, tokenIndex) {
         .map((tokens) => tokenIndex + tokens.length);
 }
 function templateMatches(source, pattern, template, start) {
+    const matchMode = template.matchMode ?? pattern.matchMode;
     let positions = [start];
     for (const part of template.parts) {
         positions = positions.flatMap((position) => matchPart(source, pattern, part, position));
@@ -145,13 +157,17 @@ function templateMatches(source, pattern, template, start) {
             return false;
         }
     }
-    if (pattern.matchMode === "contains") {
+    if (matchMode === "contains") {
         return positions.length > 0;
     }
+    if (matchMode === "connector") {
+        return positions.some((position) => ["and", "but", "so", "yet"].includes(source[position]?.normalized ?? ""));
+    }
     return positions.includes(source.length);
 }
 function templateMatchesPattern(source, pattern, template) {
-    if (pattern.matchMode === "full") {
+    const matchMode = template.matchMode ?? pattern.matchMode;
+    if (matchMode === "full" || matchMode === "connector") {
         return templateMatches(source, pattern, template, 0);
     }
     for (let start = 0; start < source.length; start += 1) {

package/dist/rules/syntactic-patterns/contrast/contrastive-aphorism.js

@@ -2,6 +2,7 @@ import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
 import { sentenceUnits } from "../../../adapters/textlint/units.js";
 import { cleanSentence, startsWithWords, tokens, trimTerminalPunctuation } from "../../../shared/matchers/prose-patterns.js";
 import { pairHasAbstractSubjectOrObject } from "./private/abstract-pair-gates.js";
+import { matchEvidenceLimitationPair } from "./private/evidence-limitation-pair.js";
 import { matchSameSentenceContrast } from "./private/same-sentence-contrast.js";
 import { matchSingleSentenceAphorism } from "./private/single-sentence-aphorism.js";
 const PREFIXES = ["and ", "but ", "so ", "because "];
@@ -104,6 +105,7 @@ const rule = defineTextlintRule({
                     matchLessMorePair(current.text, next.text) ??
                     matchGivesYouPair(current.text, next.text) ??
                     matchGetsOneAnotherPair(current.text, next.text) ??
+                    matchEvidenceLimitationPair(current.text, next.text) ??
                     matchEvaluativeContrastPair(current.text, next.text);
                 if (signal !== undefined) {
                     detections.push({

package/dist/rules/syntactic-patterns/contrast/negation-reframe.js

@@ -21,7 +21,7 @@ const rule = defineTextlintRule({
         family: "syntactic-patterns",
         id: RULE_ID
     },
-    formatMessage: (report) => `Negation reframe found: "${report.evidence}". Rewrite without the not-X-then-Y construction.`,
+    formatMessage: (report) => `Negation reframe found: "${report.evidence}". Rewrite the staged negation as a direct claim.`,
     reportPolicy: { kind: "one-to-one" },
     units: (document) => [
         ...allParagraphUnits(document),

package/dist/rules/syntactic-patterns/contrast/private/action-reframe-vocabulary.js

@@ -0,0 +1,47 @@
+export const GENERIC_ACTION_VERBS = new Set([
+    "asked",
+    "built",
+    "called",
+    "checked",
+    "checks",
+    "compare",
+    "compared",
+    "compares",
+    "crossed",
+    "decided",
+    "decides",
+    "followed",
+    "follows",
+    "found",
+    "gave",
+    "kept",
+    "left",
+    "looked",
+    "made",
+    "moved",
+    "opened",
+    "pointed",
+    "pulled",
+    "raised",
+    "rank",
+    "ranked",
+    "ranks",
+    "read",
+    "reads",
+    "reached",
+    "reasoned",
+    "reasons",
+    "returned",
+    "returns",
+    "said",
+    "sat",
+    "shifted",
+    "started",
+    "stood",
+    "stopped",
+    "took",
+    "turned",
+    "walked",
+    "went"
+]);
+//# sourceMappingURL=action-reframe-vocabulary.js.map

package/dist/rules/syntactic-patterns/contrast/private/audience-replacement.js

@@ -0,0 +1,267 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+const HUMAN_AUDIENCES = new Set([
+    "buyers",
+    "customers",
+    "people",
+    "readers",
+    "researchers",
+    "shoppers",
+    "users",
+    "visitors"
+]);
+const MACHINE_ACTORS = new Set([
+    "agent",
+    "agents",
+    "ai",
+    "algorithm",
+    "algorithms",
+    "assistant",
+    "assistants",
+    "bot",
+    "bots",
+    "crawler",
+    "crawlers",
+    "machine",
+    "machines",
+    "model",
+    "models",
+    "system",
+    "systems"
+]);
+const PREDICATES = new Map([
+    ["buy", "buy"],
+    ["buys", "buy"],
+    ["bought", "buy"],
+    ["choose", "choose"],
+    ["chooses", "choose"],
+    ["chose", "choose"],
+    ["compare", "compare"],
+    ["compares", "compare"],
+    ["compared", "compare"],
+    ["evaluate", "evaluate"],
+    ["evaluates", "evaluate"],
+    ["evaluated", "evaluate"],
+    ["find", "find"],
+    ["finds", "find"],
+    ["found", "find"],
+    ["inspect", "inspect"],
+    ["inspects", "inspect"],
+    ["inspected", "inspect"],
+    ["purchase", "purchase"],
+    ["purchases", "purchase"],
+    ["purchased", "purchase"],
+    ["read", "read"],
+    ["reads", "read"],
+    ["review", "review"],
+    ["reviews", "review"],
+    ["reviewed", "review"],
+    ["search", "search"],
+    ["searches", "search"],
+    ["searched", "search"],
+    ["select", "select"],
+    ["selects", "select"],
+    ["selected", "select"],
+    ["scan", "scan"],
+    ["scans", "scan"],
+    ["scanned", "scan"]
+]);
+const CAUSAL_CONNECTORS = new Set([
+    "after",
+    "because",
+    "if",
+    "since",
+    "therefore",
+    "until",
+    "when",
+    "while"
+]);
+const OBJECT_FILLERS = new Set([
+    "a",
+    "an",
+    "and",
+    "at",
+    "for",
+    "from",
+    "in",
+    "its",
+    "my",
+    "of",
+    "on",
+    "our",
+    "the",
+    "their",
+    "to",
+    "your"
+]);
+const OBJECT_PRONOUNS = new Set([
+    "he",
+    "her",
+    "him",
+    "it",
+    "me",
+    "she",
+    "them",
+    "they",
+    "us",
+    "we",
+    "you"
+]);
+const ARTIFACT_SURFACES = new Set([
+    "catalog",
+    "dashboard",
+    "database",
+    "feed",
+    "index",
+    "listing",
+    "page",
+    "report",
+    "site"
+]);
+function words(text) {
+    return wordTokens(text).map((token) => token.normalized);
+}
+function hasQuote(text) {
+    return [...text].some((character) => character === '"' ||
+        character === "\u201c" ||
+        character === "\u201d" ||
+        character === "`");
+}
+function hasDigit(word) {
+    return [...word].some((character) => character >= "0" && character <= "9");
+}
+function hasRejectedSurface(text, sentenceWords) {
+    return (hasQuote(text) ||
+        sentenceWords.some((word) => CAUSAL_CONNECTORS.has(word) || hasDigit(word)));
+}
+function stripTimeMarker(sentenceWords) {
+    const suffixes = [
+        ["anymore"],
+        ["now"],
+        ["any", "longer"],
+        ["these", "days"]
+    ];
+    for (const suffix of suffixes) {
+        const start = sentenceWords.length - suffix.length;
+        if (start > 0 &&
+            suffix.every((word, index) => sentenceWords[start + index] === word)) {
+            return sentenceWords.slice(0, start);
+        }
+    }
+    return undefined;
+}
+function humanAudienceEnd(sentenceWords) {
+    const first = sentenceWords[0];
+    if (first === "nobody") {
+        return 1;
+    }
+    if (first === "no" && sentenceWords[1] === "one") {
+        return 2;
+    }
+    const headIndex = first === "the" || first === "most" || first === "many" ? 1 : 0;
+    return HUMAN_AUDIENCES.has(sentenceWords[headIndex] ?? "")
+        ? headIndex + 1
+        : undefined;
+}
+function firstClaim(sentenceWords) {
+    const originalSubjectEnd = humanAudienceEnd(sentenceWords);
+    const withoutTime = stripTimeMarker(sentenceWords) ??
+        (originalSubjectEnd !== undefined &&
+            sentenceWords[originalSubjectEnd] === "no" &&
+            sentenceWords[originalSubjectEnd + 1] === "longer"
+            ? sentenceWords
+            : undefined);
+    if (withoutTime === undefined) {
+        return undefined;
+    }
+    const subjectEnd = humanAudienceEnd(withoutTime);
+    if (subjectEnd === undefined) {
+        return undefined;
+    }
+    let predicateIndex = subjectEnd;
+    const subjectStart = withoutTime[0];
+    if (subjectStart !== "nobody" && subjectStart !== "no") {
+        if (withoutTime[predicateIndex] === "don't" ||
+            withoutTime[predicateIndex] === "doesn't" ||
+            withoutTime[predicateIndex] === "didn't") {
+            predicateIndex += 1;
+        }
+        else if (withoutTime[predicateIndex] === "do" &&
+            withoutTime[predicateIndex + 1] === "not") {
+            predicateIndex += 2;
+        }
+        else if (withoutTime[predicateIndex] === "no" &&
+            withoutTime[predicateIndex + 1] === "longer") {
+            predicateIndex += 2;
+        }
+        else {
+            return undefined;
+        }
+    }
+    const predicate = PREDICATES.get(withoutTime[predicateIndex] ?? "");
+    const object = withoutTime.slice(predicateIndex + 1);
+    return predicate !== undefined && object.length > 0
+        ? { object, predicate }
+        : undefined;
+}
+function machineActorEnd(sentenceWords) {
+    let index = sentenceWords[0] === "a" ||
+        sentenceWords[0] === "an" ||
+        sentenceWords[0] === "the"
+        ? 1
+        : 0;
+    const actorStart = index;
+    while (index < actorStart + 2 &&
+        MACHINE_ACTORS.has(sentenceWords[index] ?? "")) {
+        index += 1;
+    }
+    return index > actorStart ? index : undefined;
+}
+function secondClaim(sentenceWords) {
+    const actorEnd = machineActorEnd(sentenceWords);
+    if (actorEnd === undefined) {
+        return undefined;
+    }
+    const predicate = PREDICATES.get(sentenceWords[actorEnd] ?? "");
+    const object = sentenceWords.slice(actorEnd + 1);
+    return predicate !== undefined && object.length > 0
+        ? { object, predicate }
+        : undefined;
+}
+function contentWords(object) {
+    return new Set(object.filter((word) => !OBJECT_FILLERS.has(word) && !OBJECT_PRONOUNS.has(word)));
+}
+function sharesContent(firstObject, secondObject) {
+    if (secondObject.length === 0 ||
+        secondObject.every((word) => OBJECT_PRONOUNS.has(word))) {
+        return false;
+    }
+    const firstContent = contentWords(firstObject);
+    const secondContent = contentWords(secondObject);
+    const sameContent = firstContent.size === secondContent.size &&
+        [...firstContent].every((word) => secondContent.has(word));
+    const firstCore = [...firstContent].filter((word) => !ARTIFACT_SURFACES.has(word));
+    const secondCore = [...secondContent].filter((word) => !ARTIFACT_SURFACES.has(word));
+    return (sameContent ||
+        (firstCore.length > 0 &&
+            firstCore.length === secondCore.length &&
+            firstCore.every((word) => secondCore.includes(word))));
+}
+export function matchAudienceReplacement(first, second) {
+    const firstWords = words(first);
+    const secondWords = words(second);
+    if (firstWords.length > 24 ||
+        secondWords.length > 20 ||
+        hasRejectedSurface(first, firstWords) ||
+        hasRejectedSurface(second, secondWords)) {
+        return undefined;
+    }
+    const humanClaim = firstClaim(firstWords);
+    const machineClaim = secondClaim(secondWords);
+    if (humanClaim === undefined ||
+        machineClaim?.predicate !== humanClaim.predicate ||
+        !sharesContent(humanClaim.object, machineClaim.object)) {
+        return undefined;
+    }
+    return `${first} ${second}`;
+}
+//# sourceMappingURL=audience-replacement.js.map

package/dist/rules/syntactic-patterns/contrast/private/copular-reframe.js

@@ -1,4 +1,27 @@
-import { NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+import { FACTUAL_NEGATION_CONNECTORS, NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+const AGENTIC_SYSTEM_SUBJECTS = new Set([
+    "agent",
+    "assistant",
+    "engine",
+    "model",
+    "system",
+    "tool"
+]);
+const PAYOFF_VERBS = new Set([
+    "compared",
+    "considered",
+    "encountered",
+    "entered",
+    "evaluated",
+    "found",
+    "met",
+    "qualified",
+    "ranked",
+    "reached",
+    "reviewed",
+    "selected",
+    "seen"
+]);
 export function sameSubjectCopularReframe(aTokens, bTokens) {
     const negation = findCopularNegation(aTokens);
     if (negation === undefined || !validSubject(negation.subject)) {
@@ -38,4 +61,19 @@ export function startsWithNegatedPronounCopula(tokens) {
     const predicateIndex = skipOptionalAdverbs(tokenWords, start.predicateStart);
     return NEGATION_WORDS.has(tokenWords[predicateIndex] ?? "");
 }
+export function negatedProgressiveNeverPayoff(first, second) {
+    const negation = findCopularNegation(first);
+    if (negation === undefined ||
+        !AGENTIC_SYSTEM_SUBJECTS.has(negation.subject.at(-1) ?? "") ||
+        words(first)[negation.negatedPredicateStart]?.endsWith("ing") !== true) {
+        return false;
+    }
+    const secondWords = words(second);
+    const neverIndex = secondWords.slice(1, 4).indexOf("never") + 1;
+    return (["it", "they"].includes(secondWords[0] ?? "") &&
+        neverIndex > 0 &&
+        PAYOFF_VERBS.has(secondWords[neverIndex + 1] ?? "") &&
+        !secondWords.some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        secondWords.length <= 10);
+}
 //# sourceMappingURL=copular-reframe.js.map