nollm 0.1.0 → 0.2.0

package/README.md

@@ -80,28 +80,28 @@ Files of other types, binary files, lockfiles, minified files, and files over 2
 
 ## Rules
 
-| Rule                  | Catches                                                                 |
-| --------------------- | ----------------------------------------------------------------------- |
-| `banned-word`         | genuinely, load-bearing, crutch, spearheaded, fails loudly, and friends |
-| `em-dash`             | The em dash character                                                   |
-| `bold-list-item`      | List items like `- **Label:** plain text`                               |
-| `filler-word`         | simply, seamlessly, seamless, robust                                    |
-| `llm-vocabulary`      | delve, tapestry, crucial, game-changer, battle-tested, and more         |
-| `chat-opener`         | Lines that start with "Great question", "Certainly", "Let me", and more |
-| `chat-closer`         | "Hope this helps", "Let me know if", "Feel free to", and more           |
-| `ai-disclosure`       | "As an AI", "my training data", and more                                |
-| `contrast-cliche`     | "not just X, but Y" and "it's not X, it's Y"                            |
-| `rhetorical-question` | "Why? Because" and "The result?"                                        |
-| `emoji-list`          | List items that start with an emoji                                     |
-| `diff-comment`        | Comments about the change: "no longer", "as discussed", "Previously,"   |
-| `what-comment`        | Comments that narrate the code: "This function returns", "Loop over"    |
-| `quoted-error`        | Comments that quote an error message: `"Cannot read properties of..."`  |
-| `dramatic-verb`       | blows up, dies with, falls over, chokes on, and friends                 |
-| `parenthetical-aside` | Asides like `(and their compiled handles)`                              |
-| `long-sentence`       | A sentence over 30 words                                                |
-| `wall-of-text`        | A paragraph over 120 words or 7 sentences                               |
-| `uniform-paragraphs`  | Three or more paragraphs in a row of about the same length              |
-| `uniform-sentences`   | Four or more sentences of about the same length                         |
+| Rule                      | Catches                                                                                                            |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `banned-word`             | genuinely, load-bearing, crutch, spearheaded, fails loudly, and friends                                            |
+| `em-dash`                 | The em dash character                                                                                              |
+| `bold-list-item`          | List items like `- **Label:** plain text`                                                                          |
+| `filler-word`             | simply, seamlessly, seamless, robust                                                                               |
+| `llm-vocabulary`          | delve, tapestry, crucial, game-changer, battle-tested, and more                                                    |
+| `chat-opener`             | Lines that start with "Great question", "Certainly", "Let me", and more                                            |
+| `chat-closer`             | "Hope this helps", "Let me know if", "Feel free to", and more                                                      |
+| `ai-disclosure`           | "As an AI", "my training data", and more                                                                           |
+| `contrast-cliche`         | "not just X, but Y" and "it's not X, it's Y"                                                                       |
+| `rhetorical-question`     | "Why? Because" and "The result?"                                                                                   |
+| `emoji-list`              | List items that start with an emoji                                                                                |
+| `no-short-term-relevance` | Comments that stop making sense once the change lands: "no longer", "no behavior change", "for now", "Previously," |
+| `what-comment`            | Comments that narrate the code: "This function returns", "Loop over"                                               |
+| `quoted-error`            | Comments that quote an error message: `"Cannot read properties of..."`                                             |
+| `dramatic-verb`           | blows up, dies with, falls over, chokes on, and friends                                                            |
+| `parenthetical-aside`     | Asides like `(and their compiled handles)`                                                                         |
+| `long-sentence`           | A sentence over 30 words                                                                                           |
+| `wall-of-text`            | A paragraph over 120 words or 7 sentences                                                                          |
+| `uniform-paragraphs`      | Three or more paragraphs in a row of about the same length                                                         |
+| `uniform-sentences`       | Four or more sentences of about the same length                                                                    |
 
 Run `nollm --list-rules` for the full list with the scope of each rule.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nollm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "lint against LLMisms in your codebase",
   "keywords": [
     "comments",

package/src/cli.js

@@ -61,7 +61,7 @@ export async function main(
   if (values["list-rules"]) {
     for (let i = 0; i < rules.length; i++) {
       const scope = (rules[i].scope ?? "text").padEnd(10);
-      stdout.write(`${rules[i].id.padEnd(20)} ${scope} ${rules[i].message}\n`);
+      stdout.write(`${rules[i].id.padEnd(24)} ${scope} ${rules[i].message}\n`);
     }
     return 0;
   }

package/src/config.js

@@ -62,7 +62,7 @@ function resolveRules(overrides = {}, words = []) {
 
   for (let i = 0; i < builtinRules.length; i++) {
     const rule = builtinRules[i];
-    const override = overrides[rule.id];
+    const override = overrideFor(overrides, rule);
     if (override === false) continue;
     rules.push(isObject(override) ? customRule(rule.id, override, rule) : rule);
   }
@@ -70,7 +70,7 @@ function resolveRules(overrides = {}, words = []) {
   for (const id in overrides) {
     const override = overrides[id];
     if (!isObject(override)) continue;
-    if (builtinRules.some((rule) => rule.id === id)) continue;
+    if (builtinRules.some((rule) => namesOf(rule).includes(id))) continue;
     rules.push(customRule(id, override));
   }
 
@@ -86,6 +86,18 @@ function resolveRules(overrides = {}, words = []) {
   return rules;
 }
 
+/**
+ * The config entry for a built in rule, under its id or one of its old ids.
+ */
+function overrideFor(overrides, rule) {
+  const name = namesOf(rule).find((candidate) => candidate in overrides);
+  return name === undefined ? undefined : overrides[name];
+}
+
+function namesOf(rule) {
+  return [rule.id].concat(rule.aliases ?? []);
+}
+
 /**
  * Builds a rule from a config entry.
  * Keys that the entry leaves out come from the built in rule, when there is one.

package/src/index.d.ts

@@ -2,6 +2,8 @@ export type Scope = "prose" | "comments" | "text" | "everywhere";
 
 export interface PatternRule {
   id: string;
+  /** Old ids of this rule. A config may still refer to the rule by one of them. */
+  aliases?: string[];
   message: string;
   pattern: RegExp;
   scope?: Scope;
@@ -15,6 +17,8 @@ export interface ShapeFinding {
 
 export interface CheckRule {
   id: string;
+  /** Old ids of this rule. A config may still refer to the rule by one of them. */
+  aliases?: string[];
   message: string;
   check: (segments: Segment[], scope: Scope) => ShapeFinding[];
   scope?: Scope;

package/src/rules.js

@@ -131,17 +131,55 @@ const AI_DISCLOSURES = [
   "my training data",
 ];
 
-const DIFF_TALK = [
+// Talk that only makes sense while the change is under review.
+// Once merged, nobody reading the code knows what "the old way" or "this PR" was.
+const PR_TALK = [
+  // The change itself
   "as requested",
   "as discussed",
   "per the discussion",
   "per our discussion",
   "per the review",
   "per review",
+  "per feedback",
+  "based on feedback",
+  "review feedback",
+  "review comment",
+  "review comments",
+  "addressing feedback",
+  "addresses feedback",
+  "addressed feedback",
+  "requested changes",
+  "code review",
+  "reviewer",
+  "reviewers",
   "this pr",
+  "this mr",
+  "pr description",
+  "pull request",
+  "merge request",
   "this commit",
   "this diff",
   "this change",
+  "this refactor",
+  "the refactor",
+  "this migration",
+  "this upgrade",
+  "the upgrade",
+  "after upgrading",
+  "before upgrading",
+  "since upgrading",
+  "version bump",
+  "this bump",
+  "cherry-picked",
+  "cherry picked",
+  "backported",
+  "rebased",
+  "merge conflict",
+  "merge conflicts",
+  "work in progress",
+  "wip",
+  // How the code used to be
   "no longer",
   "used to be",
   "used to use",
@@ -164,10 +202,176 @@ const DIFF_TALK = [
   "now handles",
   "now lives",
   "moved to",
+  "never worked",
+  "wasn't working",
+  "was not working",
+  "weren't working",
+  "were not working",
+  "didn't work before",
+  "did not work before",
+  "stopped working",
+  "was failing",
+  "were failing",
+  "started failing",
+  "kept failing",
+  "on the main branch",
+  "on the master branch",
+  "compared to main",
+  "compared to master",
+  // Claims that nothing changed
+  "no behavior change",
+  "no behaviour change",
+  "no functional change",
+  "no functional changes",
+  "no-op change",
+  "behavior is unchanged",
+  "behaviour is unchanged",
+  "behavior unchanged",
+  "behaviour unchanged",
+  "no change in behavior",
+  "no change in behaviour",
+  "same as before",
+  "same behavior as before",
+  "same behaviour as before",
+  "behaves as before",
+  "behaves the same",
+  "works the same",
+  "functionally equivalent",
+  "functionally identical",
+  "preserves behavior",
+  "preserves behaviour",
+  "preserve behavior",
+  "preserve behaviour",
+  "preserves existing behavior",
+  "preserves existing behaviour",
+  "existing behavior",
+  "existing behaviour",
+  "unchanged from",
+  // Leaving things as they were
+  "keeping it off",
+  "keeping it on",
+  "keeping this off",
+  "keeping this on",
+  "keeping it disabled",
+  "keeping it enabled",
+  "keeping this disabled",
+  "keeping this enabled",
+  "keep it off",
+  "keep this off",
+  "kept as is",
+  "kept as-is",
+  "left as is",
+  "left as-is",
+  "leave as is",
+  "leave as-is",
+  "leaving as is",
+  "leaving as-is",
+  "left in place",
+  "left untouched",
+  "left alone",
+  "leaving this alone",
+  "not touching",
+  "didn't touch",
+  "did not touch",
+  // Scope and follow-ups
+  "for now",
+  "out of scope",
+  "scope of this",
+  "follow-up pr",
+  "follow up pr",
+  "in a follow-up",
+  "in a follow up",
+  "as a follow-up",
+  "as a follow up",
+  "separate pr",
+  "later pr",
+  "future pr",
+  "another pr",
+  "next pr",
+  "will be removed",
+  "can be removed",
+  "to be removed",
+  "should be removed",
+  "safe to remove",
+  "safe to delete",
+  "can be deleted",
+  "will be deleted",
+  "remove this once",
+  "remove this after",
+  "remove this when",
+  "delete this once",
+  "delete this after",
+  "clean up later",
+  "cleanup later",
+  "clean this up later",
+  "will clean up",
+  "will be cleaned up",
+  "quick fix",
+  "quick hack",
+  "quick and dirty",
+  "band-aid",
+  "bandaid",
+  "band aid",
+  "stopgap",
+  "stop-gap",
+  "stop gap",
+  "hotfix",
+  "hot fix",
+  // The author talking about their own process
+  "tested locally",
+  "verified locally",
+  "confirmed locally",
+  "works locally",
+  "tested with",
+  "tested on",
+  "tested against",
+  "verified with",
+  "confirmed with",
+  "ci passes",
+  "passes ci",
+  "ci is green",
+  "ci was failing",
+  "ci fails",
+  "ci failed",
+  "i tested",
+  "i verified",
+  "i checked",
+  "i confirmed",
+  "i tried",
+  "i went with",
+  "i chose",
+  "i opted",
+  "i decided",
+  "i ended up",
+  "i left",
+  "i kept",
+  "i removed",
+  "i replaced",
+  "i added",
+  "i moved",
+  "i renamed",
+  "i changed",
+  "i updated",
+  "i bumped",
+  "i couldn't",
+  "i could not",
+  "i'm not sure",
+  "i am not sure",
+  "not sure if",
+  "not sure why",
+  "not sure whether",
+  "we tested",
+  "we verified",
+  "we confirmed",
+  "we decided",
+  "we went with",
+  "we opted",
+  "we couldn't",
+  "we could not",
 ];
 
-// Diff talk only when it opens a sentence. "used previously" is fine.
-const DIFF_OPENERS = ["previously", "formerly"];
+// PR talk only when it opens a sentence. "used previously" is fine.
+const PR_OPENERS = ["previously", "formerly", "originally"];
 
 const DRAMATIC_VERBS = [
   "blow up",
@@ -323,10 +527,11 @@ export const rules = [
     scope: "prose",
   },
   {
-    id: "diff-comment",
-    message: "Comment describes the change, not the code. Put it in the commit message",
+    id: "no-short-term-relevance",
+    aliases: ["diff-comment"],
+    message: "Comment only makes sense while the change is under review. Say it in the PR",
     pattern: new RegExp(
-      String.raw`\b(?:${words(DIFF_TALK)})\b|${SENTENCE_START}(?:${words(DIFF_OPENERS)})\b`,
+      String.raw`\b(?:${words(PR_TALK)})\b|${SENTENCE_START}(?:${words(PR_OPENERS)})\b`,
       "gmi",
     ),
     scope: "comments",