@mark1russell7/ste-lint 0.0.0-bootstrap.0 → 0.1.1

package/src/text/words.ts

@@ -0,0 +1,183 @@
+/**
+ * Closed word classes and short word lists for the grammar heuristics.
+ *
+ * These lists are general English grammar. They do not come from the
+ * ASD-STE100 dictionary. The linter cannot tag parts of speech, so the
+ * heuristics look at the words near a word to guess how the text uses it.
+ */
+
+const set = (words : string) : ReadonlySet<string> => new Set(words.trim().split(/\s+/));
+
+export const DETERMINERS : ReadonlySet<string> = set(`
+    a an the this that these those each every all any some no its their your our my his her
+    another other either neither both many much more most few several such which whose what one
+`);
+
+export const SUBJECT_PRONOUNS : ReadonlySet<string> = set("i you we they he she it this that which who there");
+
+export const OBJECT_PRONOUNS : ReadonlySet<string> = set("me you us them him her it itself themselves this these those");
+
+/** Forms of "be", with the contractions that contain "is", "are" or "am". */
+export const BE_FORMS : ReadonlySet<string> = set(`
+    am is are was were be been being isn't aren't wasn't weren't it's that's there's here's what's who's
+    he's she's they're we're you're i'm
+`);
+
+/** Words before a past participle that make a passive: forms of "be" and "get". */
+export const PASSIVE_AUXILIARIES : ReadonlySet<string> = new Set([...BE_FORMS, "get", "gets", "got", "gotten", "getting"]);
+
+export const HAVE_FORMS : ReadonlySet<string> = set("have has had having haven't hasn't hadn't");
+
+export const DO_FORMS : ReadonlySet<string> = set("do does did don't doesn't didn't");
+
+export const MODALS : ReadonlySet<string> = set(`
+    can cannot could may might must shall should will would can't couldn't mustn't shouldn't won't wouldn't
+`);
+
+export const PREPOSITIONS : ReadonlySet<string> = set(`
+    about above across after against along among around as at before behind below beneath beside between
+    beyond by despite down during except for from in inside into like near of off on onto out outside over
+    past per since through throughout to toward towards under until up upon via with within without
+`);
+
+export const CONJUNCTIONS : ReadonlySet<string> = set(`
+    and or but nor so yet if when while because although though unless until whether that where once than
+`);
+
+/** Words that start a condition or purpose clause before the main clause. */
+export const CLAUSE_STARTERS : ReadonlySet<string> = set(`
+    if when whenever before after while until unless once to for in on at during because as since where
+    with without by from although though
+`);
+
+/** Words that can come before the verb of an imperative sentence. */
+export const LEADING_ADVERBS : ReadonlySet<string> = set(`
+    then first next also finally optionally now please second third afterward afterwards alternatively
+    instead always only just simply again manually carefully immediately
+`);
+
+/** Adverbs that can come between an auxiliary verb and a participle. */
+export const MIDDLE_ADVERBS : ReadonlySet<string> = set(`
+    not also always never only then still already often usually automatically immediately sometimes just
+    all both each first again correctly currently directly fully later normally now once possibly
+    probably quickly rarely really safely silently simply successfully typically
+`);
+
+/** Words that tell the reader that a clause is a condition, so a participle after "be" is a state. */
+export const CONDITION_MARKERS : ReadonlySet<string> = set(`
+    if when whenever until unless while after before once whether sure that because since
+`);
+
+export const PARTICLES : ReadonlySet<string> = set("up out down off back over away");
+
+export const NUMBER_WORDS : ReadonlySet<string> = set(`
+    zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen
+    seventeen eighteen nineteen twenty thirty forty fifty sixty seventy eighty ninety hundred hundreds
+    thousand thousands million millions billion billions dozen dozens half twice
+`);
+
+/** Units of measurement. A number and its unit count as one word (STE Rule 8.6). */
+export const UNITS : ReadonlySet<string> = set(`
+    ns µs μs us ms s sec secs second seconds millisecond milliseconds microsecond microseconds nanosecond
+    nanoseconds min mins minute minutes h hr hrs hour hours day days week weeks month months year years
+    b byte bytes kb mb gb tb kib mib gib tib kilobyte kilobytes megabyte megabytes gigabyte gigabytes
+    % percent px pixel pixels hz khz mhz ghz fps °c °f degree degrees kg g mm cm m km kilogram kilograms
+    gram grams kilometer kilometers liter liters litre litres inch inches
+`);
+
+/**
+ * Words that end in "-ing" but are usually not verb forms: nouns, adjectives,
+ * prepositions, and base forms, for example "bring".
+ */
+export const NON_VERB_ING : ReadonlySet<string> = set(`
+    thing things string strings ring rings spring springs king kings wing wings sing bring brings during
+    something anything everything nothing morning mornings evening evenings ceiling ceilings sibling
+    siblings duckling earring inkling offspring pudding sterling swing swings sling wring cling fling
+    sting
+    outstanding ongoing upcoming incoming outgoing missing remaining pending interesting confusing
+    misleading surprising promising demanding challenging exciting annoying boring willing worrying
+    overwhelming existing corresponding underlying trailing preceding notwithstanding
+    timing padding heading spacing wording warning beginning opening
+`);
+
+/** Irregular past participles. A participle after "be" makes a passive. */
+export const IRREGULAR_PARTICIPLES : ReadonlySet<string> = set(`
+    arisen awoken begun bent bitten blown bound broken brought built bought caught chosen cut dealt done
+    drawn driven eaten fallen fed felt fought found flown forbidden forgotten forgiven frozen gotten given
+    gone grown hung heard hidden hit held hurt kept known laid led left lent let lost made meant met paid
+    put quit read rebuilt reset rerun ridden rung risen run said seen sought sold sent set shaken shown
+    shut sung sunk slept slid spoken spent spun split spread stood stolen stuck struck sworn swept taken
+    taught torn told thought thrown undone understood unset upset withdrawn woken worn won wound written
+    overridden rewritten overwritten bitten
+`);
+
+/** Words that end in "-ed" but are not past participles. */
+export const NOT_PARTICIPLE_ED : ReadonlySet<string> = set(`
+    need needed bed red shed feed seed speed bleed breed deed embed exceed proceed succeed indeed hundred
+    kindred sacred naked wicked rugged ragged aged beloved learned
+`);
+
+/**
+ * Common verbs in their base form. The imperative heuristic and the
+ * missing-subject heuristic use this list. The project glossary adds
+ * technical verbs to it.
+ */
+export const COMMON_VERBS : ReadonlySet<string> = set(`
+    accept access activate add adjust allow apply assign attach avoid begin bind block break bring build
+    calculate call cancel capture change check choose clean clear click clone close collect combine commit
+    compare compile complete compute configure confirm connect consider contain continue control convert
+    copy correct count cover create deactivate debug decide declare decrease define delay delete deliver
+    depend deploy describe destroy detach detect determine disable disconnect discard dispatch display
+    dispose do download drag drop emit enable end enforce enqueue ensure enter estimate examine exclude
+    execute exit expand expect explain export expose extend extract fail fetch fill filter find finish fire
+    fix flag flush follow force forward freeze generate get give go grant group handle hold ignore implement
+    import include increase indicate initialize insert inspect install invoke keep kill launch leave let
+    limit link list listen load lock log look make manage map mark match measure merge migrate mock modify
+    monitor mount move name navigate need note notify observe obtain omit open operate override parse pass
+    paste pause perform pick pin place point poll post prefer prepare press prevent print process produce
+    provide publish pull push put queue read rebuild reboot receive record reduce refer refresh register
+    reject release reload remember remove rename render repeat replace report request require reschedule
+    reset resize resolve respond restart restore resume retry return reuse review revert rotate run sample
+    save schedule scroll search select send serve set share show shut sign skip sleep sort specify split
+    start stay step stop store submit subscribe substitute supply support swap switch sync take tap tell
+    terminate test throttle throw tick toggle touch track transform trigger try turn type uncomment
+    uninstall unlock unpin unregister unsubscribe update upgrade upload use validate verify view visit wait
+    wake warn watch wrap write yield
+    agree appear arrive ask become belong come differ exist happen help know occur overlap reach remain
+    seem survive think want
+`);
+
+/**
+ * Nouns that software text often uses before another noun. The noun-cluster
+ * heuristic counts only these words, technical nouns, proper nouns,
+ * abbreviations and code. Words that are frequently verbs are not in this
+ * list, so the heuristic does not count a verb as a noun.
+ */
+export const COMMON_NOUNS : ReadonlySet<string> = set(`
+    attribute browser buffer bucket byte cache callback channel chart clock collector column component config
+    configuration console constructor container context counter dashboard data database delay dependency
+    deployment device dialog directory document domain duration element endpoint entry environment error
+    event exception exporter factory field file folder frame framework function gauge handler hardware
+    header heap heartbeat histogram history host id identifier index input instance interface interval item
+    key keyboard label latency layer layout length level library lifecycle line listener logger loop
+    machine memory message meter method metric millisecond mode model module monitor mouse network node
+    number object observer offset option origin output owner package page pair parameter parser path
+    pattern payload percentile period permission phase pipeline platform plugin pointer policy pool port
+    position pressure priority problem procedure processor profile program project promise property protocol
+    provider proxy quantity query range rate ratio reader reason receiver recorder reference region registry
+    renderer repository resolution resource response router runtime scheduler schema scope screen script
+    second section selector sender sequence server service session setting signal size slot snapshot socket
+    source span stack stage standard state statement status storage stream string structure style
+    subscriber suite summary symbol syntax system tab table target task template terminal text thread
+    threshold time timeout timer timestamp title token tool topic trace transaction transport tree tuple
+    unit url usage user utility validator value variable vendor version viewport visibility warning window
+    worker workspace wrapper
+`);
+
+/** Abbreviations after which a period does not end a sentence. */
+export const NO_BREAK_ABBREVIATIONS : ReadonlySet<string> = set(`
+    e.g i.e vs viz cf al approx mr mrs dr st jr sr inc ltd corp u.s a.m p.m
+`);
+
+/** Abbreviations that do not end a sentence when a number comes after them, for example "Fig. 3". */
+export const NUMBER_ABBREVIATIONS : ReadonlySet<string> = set("fig figs eq eqs no nos ref vol ch pp p sec para");

package/src/types.ts

@@ -0,0 +1,39 @@
+export type Severity = "error" | "warning";
+
+/** The setting of a rule in `ste.config.json`. */
+export type RuleSetting = Severity | "off";
+
+export const RULE_IDS = [
+    "sentence-length",
+    "paragraph-length",
+    "modal-verb",
+    "semicolon",
+    "latin-abbreviation",
+    "about-quantity",
+    "word-list",
+    "gendered-pronoun",
+    "first-person",
+    "passive-instruction",
+    "noun-cluster",
+    "missing-subject",
+    "ing-verb",
+    "unknown-word",
+] as const;
+
+export type RuleId = (typeof RULE_IDS)[number];
+
+/** One problem that the linter found. Lines and columns start at 1. */
+export type Finding = {
+    readonly file : string;
+    readonly line : number;
+    readonly column : number;
+    readonly endLine : number;
+    readonly endColumn : number;
+    readonly ruleId : RuleId;
+    readonly severity : Severity;
+    readonly message : string;
+};
+
+export function isRuleId(value : string) : value is RuleId {
+    return (RULE_IDS as readonly string[]).includes(value);
+}

package/src/units.ts

@@ -0,0 +1,86 @@
+/**
+ * Prose units: the blocks of text that the rules examine, with their tokens
+ * and sentences.
+ */
+
+import type { Lexicon } from "./lexicon.js";
+import type { ListContext, ProseBlock } from "./source/blocks.js";
+import { normalizeInline } from "./source/inline.js";
+import { isInstruction } from "./text/grammar.js";
+import { countWords, splitSentences } from "./text/sentences.js";
+import { isCounted, tokenize, type Token } from "./text/tokens.js";
+
+export type TsdocSection = "summary" | "remarks" | "tag";
+
+/** Where a block comes from. */
+export type BlockOrigin = {
+    readonly source : "markdown" | "mdx" | "tsdoc" | "jsx";
+    /** For a doc comment: the summary, the `@remarks` section, or the text of another block tag. */
+    readonly tsdocSection : TsdocSection | null;
+    /** For a doc comment: the block tag, for example `@param`, or null for the summary. */
+    readonly tsdocTag : string | null;
+};
+
+export type ExtractedBlock = {
+    readonly block : ProseBlock;
+    readonly origin : BlockOrigin;
+};
+
+export type Sentence = {
+    /** All tokens of the sentence, with the punctuation. */
+    readonly tokens : readonly Token[];
+    /** The STE word count. */
+    readonly words : number;
+    /** The tokens in each top-level parenthesis. Each one counts as a separate sentence. */
+    readonly parentheticals : readonly (readonly Token[])[];
+    /** True when the sentence is an instruction (imperative). */
+    readonly instruction : boolean;
+    readonly start : number;
+    readonly end : number;
+};
+
+export type UnitKind = ProseBlock["kind"];
+
+export type ProseUnit = {
+    readonly kind : UnitKind;
+    readonly origin : BlockOrigin;
+    readonly list : ListContext | null;
+    readonly tokens : readonly Token[];
+    readonly sentences : readonly Sentence[];
+    readonly start : number;
+    readonly end : number;
+};
+
+/** This function makes a prose unit from a block. The result is null when the block has no words. */
+export function buildUnit(extracted : ExtractedBlock, lexicon : Lexicon) : ProseUnit | null {
+    const { block, origin } = extracted;
+    const inline = normalizeInline(block.lines, { mdx : origin.source === "mdx" || origin.source === "jsx", tsdoc : origin.source === "tsdoc" });
+    return unitFromTokens(tokenize(inline), block, origin, lexicon);
+}
+
+/** This function makes a prose unit from the tokens of a block. */
+export function unitFromTokens(tokens : readonly Token[], block : Pick<ProseBlock, "kind" | "list">, origin : BlockOrigin, lexicon : Lexicon) : ProseUnit | null {
+    if (!tokens.some(isCounted)) return null;
+    const ranges = block.kind === "paragraph" ? splitSentences(tokens) : [{ from : 0, to : tokens.length }];
+    const sentences : Sentence[] = ranges.map((range) => {
+        const sentenceTokens = tokens.slice(range.from, range.to);
+        const count = countWords(sentenceTokens, { properNouns : lexicon.properNounPhrases });
+        return {
+            tokens : sentenceTokens,
+            words : count.words,
+            parentheticals : count.parentheticals,
+            instruction : block.kind === "paragraph" && isInstruction(sentenceTokens, { verbs : lexicon.verbs }),
+            start : sentenceTokens[0]!.start,
+            end : sentenceTokens[sentenceTokens.length - 1]!.end,
+        };
+    });
+    return {
+        kind : block.kind,
+        origin,
+        list : block.list,
+        tokens,
+        sentences,
+        start : tokens[0]!.start,
+        end : tokens[tokens.length - 1]!.end,
+    };
+}

package/src/word-list.ts

@@ -0,0 +1,128 @@
+/**
+ * The project word list: plain-language substitutions for the documentation
+ * of this repository. This list is the style guide of the project, written
+ * for it. It is not a copy of the ASD-STE100 dictionary. The local
+ * dictionary file (refer to `dictionary.ts`) does that job, and it is not
+ * part of the repository at any time.
+ *
+ * Each entry has the words or phrases to find, the words to write instead,
+ * and a severity. `ste.config.json` can add entries, change them, or set an
+ * entry to "off".
+ */
+
+import type { Severity } from "./types.js";
+
+export type WordListEntry = {
+    /** A short name of the entry. A configuration entry with the same ID changes this entry. */
+    readonly id : string;
+    /** The words and phrases to find. The match ignores case. */
+    readonly match : readonly string[];
+    /** The words to write instead, as the message shows them. Null when the fix is to remove the word. */
+    readonly suggest : string | null;
+    /** More help for the message, or null. */
+    readonly note : string | null;
+    readonly severity : Severity;
+    /**
+     * True when the word can be a noun too. Then the rule reports the word
+     * only when the words near it show a verb ("Run the tests", but not "a
+     * test run").
+     */
+    readonly verbOnly : boolean;
+    /** A special context: "reference" finds "see" only where it tells the reader to look at other text. */
+    readonly context : "reference" | null;
+};
+
+type EntryInput = {
+    readonly match : readonly string[];
+    readonly suggest? : string;
+    readonly note? : string;
+    readonly severity? : Severity;
+    readonly verbOnly? : boolean;
+    readonly context? : "reference";
+    readonly id? : string;
+};
+
+function entry(input : EntryInput) : WordListEntry {
+    return {
+        id : input.id ?? input.match[0]!,
+        match : input.match,
+        suggest : input.suggest ?? null,
+        note : input.note ?? null,
+        severity : input.severity ?? "error",
+        verbOnly : input.verbOnly ?? false,
+        context : input.context ?? null,
+    };
+}
+
+/** The default word list. */
+export const DEFAULT_WORD_LIST : readonly WordListEntry[] = [
+    // Long or formal words that have a short, common equivalent.
+    entry({ match : ["utilize", "utilizes", "utilized", "utilizing", "utilization", "utilise", "utilises", "utilised", "utilising"], suggest : "\"use\"" }),
+    entry({ match : ["initiate", "initiates", "initiated", "initiating"], suggest : "\"start\"" }),
+    entry({ match : ["ensure", "ensures", "ensured", "ensuring"], suggest : "\"make sure\"", note : "Write \"that\" after it: \"make sure that ...\"." }),
+    entry({ match : ["via"], suggest : "\"through\" or \"with\"" }),
+    entry({ match : ["leverage", "leverages", "leveraged", "leveraging"], suggest : "\"use\"" }),
+    entry({ match : ["facilitate", "facilitates", "facilitated", "facilitating"], suggest : "\"help\" or \"make ... easier\"" }),
+    entry({ match : ["commence", "commences", "commenced", "commencing"], suggest : "\"start\"" }),
+    entry({ match : ["terminate", "terminates", "terminated", "terminating"], suggest : "\"stop\"" }),
+    entry({ match : ["obtain", "obtains", "obtained", "obtaining"], suggest : "\"get\"" }),
+    entry({ match : ["assist", "assists", "assisted", "assisting"], suggest : "\"help\"" }),
+    entry({ match : ["modify", "modifies", "modified", "modifying"], suggest : "\"change\"" }),
+    entry({ match : ["indicate", "indicates", "indicated", "indicating"], suggest : "\"show\"" }),
+    entry({ match : ["demonstrate", "demonstrates", "demonstrated", "demonstrating"], suggest : "\"show\"" }),
+    entry({ match : ["perform", "performs", "performed", "performing"], suggest : "\"do\"" }),
+    entry({ match : ["attempt", "attempts", "attempted", "attempting"], suggest : "\"try\"" }),
+    entry({ match : ["numerous"], suggest : "\"many\", or give the number" }),
+    entry({ match : ["additional"], suggest : "\"more\"" }),
+    entry({ match : ["additionally"], suggest : "\"also\"" }),
+    entry({ match : ["regarding"], suggest : "\"about\"" }),
+    entry({ match : ["hence"], suggest : "\"thus\"" }),
+
+    // Phrases that have a shorter equivalent.
+    entry({ match : ["prior to"], suggest : "\"before\"" }),
+    entry({ match : ["in order to"], suggest : "\"to\"" }),
+    entry({ match : ["due to the fact that"], suggest : "\"because\"" }),
+    entry({ match : ["due to"], suggest : "\"because of\"" }),
+    entry({ match : ["in the event that"], suggest : "\"if\"" }),
+    entry({ match : ["at this point in time"], suggest : "\"at this time\"" }),
+    entry({ match : ["in an effort to"], suggest : "\"to\"" }),
+    entry({ match : ["for the purpose of"], suggest : "\"to\" or \"for\"" }),
+    entry({ match : ["with respect to", "with regard to"], suggest : "\"about\" or \"for\"" }),
+    entry({ match : ["as well as"], suggest : "\"and\"" }),
+    entry({ match : ["a number of"], suggest : "\"some\", or give the number" }),
+    entry({ match : ["is able to", "are able to", "be able to"], suggest : "\"can\"" }),
+    entry({ match : ["such as"], suggest : "\"for example\"" }),
+    entry({ match : ["follow these steps", "follow the steps"], suggest : "\"do these steps\" or \"do the steps\"" }),
+
+    // Connecting words.
+    entry({ match : ["however"], suggest : "\"but\"", note : "Start a new sentence with \"But\" if necessary." }),
+    entry({ match : ["therefore"], suggest : "\"thus\" or \"as a result\"" }),
+    entry({ match : ["whether or not", "whether"], suggest : "\"if\"" }),
+
+    // Verbs that have a simpler equivalent.
+    entry({ match : ["allow", "allows", "allowed", "allowing"], suggest : "\"let\" or \"lets\"", note : "For an adjective, write \"permitted\"." }),
+    entry({ match : ["require", "requires", "required", "requiring"], suggest : "\"necessary\"", note : "For example, write \"X is necessary for Y\", or use the imperative." }),
+    entry({ match : ["provided that"], suggest : "\"if\"" }),
+    entry({ match : ["provide", "provides", "provided", "providing"], suggest : "\"give\" or \"gives\"" }),
+    entry({ match : ["execute", "executes", "executed", "executing"], suggest : "\"do\", \"does\" or \"start\"" }),
+    entry({ match : ["create", "creates", "created", "creating"], suggest : "\"make\" or \"makes\"" }),
+    entry({ match : ["kill", "kills", "killed", "killing"], suggest : "\"stop\"" }),
+    entry({ id : "displays", match : ["displayed", "displaying"], suggest : "\"show\" or \"shows\"", severity : "warning" }),
+    entry({ id : "display", match : ["display", "displays"], suggest : "\"show\" or \"shows\"", severity : "warning", verbOnly : true }),
+    entry({ id : "returns", match : ["returns", "returned", "returning"], suggest : "\"gives\"", severity : "warning", note : "For a function, write \"This function gives ...\"." }),
+    entry({ id : "return", match : ["return"], suggest : "\"give\" or \"gives\"", severity : "warning", verbOnly : true }),
+    entry({ id : "call", match : ["call", "calls", "called", "calling"], suggest : "\"use\" or \"start\"", severity : "warning", verbOnly : true, note : "This applies when the verb means to start a function." }),
+    entry({ id : "ran", match : ["ran"], suggest : "\"started\" or \"operated\"", severity : "warning" }),
+    entry({ id : "run", match : ["run", "runs", "running"], suggest : "\"start\", \"starts\" or \"operates\"", severity : "warning", verbOnly : true }),
+    entry({ id : "see", match : ["see"], suggest : "\"refer to\"", severity : "warning", context : "reference" }),
+
+    // Words that do not add information.
+    entry({ match : ["simple", "simply", "easily"], severity : "warning", note : "The word tells the reader what to think. Tell the reader what to do." }),
+    entry({ match : ["just"], suggest : "\"only\"", severity : "warning", note : "Or remove the word." }),
+    entry({ match : ["basically", "obviously", "of course"], severity : "warning", note : "The word does not add information." }),
+    entry({ match : ["please"], severity : "warning", note : "Write the instruction in the imperative." }),
+
+    // Time and negation.
+    entry({ match : ["currently", "now"], suggest : "\"at this time\"", note : "Or remove the word if the time is clear." }),
+    entry({ match : ["never"], suggest : "\"do not\"", note : "For a description, write \"not ... at any time\"." }),
+];

package/ste.config.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/mark1russell7/ste-lint/main/ste.config.schema.json",
+  "title": "ste-lint configuration",
+  "description": "The configuration of ste-lint. All properties are optional.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "include": {
+      "description": "Glob patterns of the files to examine, relative to this file.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "ignore": {
+      "description": "Glob patterns of the files not to examine, relative to this file.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "technicalNouns": {
+      "description": "Technical nouns of the project glossary. A term can have more than one word.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "technicalVerbs": {
+      "description": "Technical verbs of the project glossary, in the base form.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "properNouns": {
+      "description": "Names of products, organizations and standards. A name with more than one word counts as one word.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "allowedWords": {
+      "description": "Other words that the -ing rule and the unknown-word rule accept.",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "rules": {
+      "description": "The severity of each rule.",
+      "type": "object",
+      "propertyNames": {
+        "enum": [
+          "sentence-length", "paragraph-length", "modal-verb", "semicolon", "latin-abbreviation", "about-quantity",
+          "word-list", "gendered-pronoun", "first-person", "passive-instruction", "noun-cluster", "missing-subject",
+          "ing-verb", "unknown-word"
+        ]
+      },
+      "additionalProperties": { "enum": ["error", "warning", "off"] }
+    },
+    "wordList": {
+      "description": "Entries to add to the project word list, or to change in it.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "anyOf": [{ "required": ["id"] }, { "required": ["match"] }],
+        "properties": {
+          "id": { "description": "The ID of a default entry to change.", "type": "string" },
+          "match": {
+            "description": "The words or phrases to find.",
+            "anyOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" }, "minItems": 1 }]
+          },
+          "suggest": { "description": "The words to write instead, as the message shows them.", "type": ["string", "null"] },
+          "note": { "description": "More help for the message.", "type": ["string", "null"] },
+          "severity": { "enum": ["error", "warning", "off"] },
+          "verbOnly": { "description": "Find the words only where they are verbs.", "type": "boolean" }
+        }
+      }
+    },
+    "limits": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "instructionWords": { "type": "integer", "minimum": 1, "default": 20 },
+        "descriptionWords": { "type": "integer", "minimum": 1, "default": 25 },
+        "paragraphSentences": { "type": "integer", "minimum": 1, "default": 6 },
+        "nounClusterNouns": { "type": "integer", "minimum": 1, "default": 3 }
+      }
+    },
+    "dictionaryPath": {
+      "description": "The path of a local dictionary file. Never commit a dictionary. The environment variable STE_DICTIONARY has priority.",
+      "type": ["string", "null"]
+    }
+  }
+}