@konvert7/klint 1.4.0 → 1.5.0

package/README.md

@@ -745,8 +745,8 @@ doc-comments alongside `/** */`.
 | `no-string-match` | `String#match()` usage better expressed with clearer APIs |
 | `blank-line-before-control-flow` | Blank line above a control-flow statement that follows another statement; autofix |
 | `blank-line-after-block` | Blank line below a block statement when another statement follows; autofix |
-| `cognitive-complexity` | Function whose cognitive complexity (Biome / SonarSource model) is above `max`, in all five languages; opt-in, no autofix |
-| `function-length` | Function whose body has more lines than `max` (counted like Biome's `noExcessiveLinesPerFunction`), in all five languages; opt-in, no autofix |
+| `cognitive-complexity` | Function whose cognitive complexity (SonarJS / SonarSource model) is above its `warn`/`error` limits, in all five languages; opt-in, no autofix |
+| `function-length` | Function whose body has more lines than its `warn`/`error` limits (counted like Biome's `noExcessiveLinesPerFunction`), in all five languages; opt-in, no autofix |
 
 Rules that needed TypeScript's type checker were removed in 1.0; see [Upgrading from klint 0.x](#upgrading-from-klint-0x).
 
@@ -800,7 +800,7 @@ rules:
 
 ### Cognitive complexity
 
-`cognitive-complexity` reports every function whose cognitive complexity is above `max`, in TypeScript/JavaScript, Python, Swift, Rust and C#. It is opt-in and has no fix. It uses Biome 2.6.5's `noExcessiveCognitiveComplexity` scoring (the SonarSource Cognitive Complexity model, G. Ann Campbell 2017) for every language, so a TypeScript function gets the same score as in Biome.
+`cognitive-complexity` reports every function whose cognitive complexity is above its `warn` or `error` limit, in TypeScript/JavaScript, Python, Swift, Rust and C#. It is opt-in and has no fix. It scores like SonarSource's own implementation, `eslint-plugin-sonarjs` 3.0.5 rule S3776 (the SonarSource Cognitive Complexity model, G. Ann Campbell 2017), for every language, so a TypeScript function gets the same score as in SonarJS.
 
 ```yaml
 rules:
@@ -808,50 +808,69 @@ rules:
     cognitive-complexity: error
 ```
 
+```yaml
+rules:
+  core:
+    cognitive-complexity: {warn: 10, error: 20}
+```
+
 ```yaml
 rules:
   core:
     cognitive-complexity:
-      severity: warn
-      include: ["src/**", "!src/generated/**"]
-      max: 14
+      - {error: 15}
+      - {warn: 10, error: 20, include: ["scripts/**"]}
 ```
 
-- `max` is an integer of at least 1, default 15. A function is reported when its score is **greater than** `max`. Any other value (0, a negative number, a fraction, a string) gives one `klint/config` warning naming the rule and the value, and the rule uses 15.
-- The message has the form ``Function `big` has cognitive complexity 16 (max 15) — split it into smaller functions.``. The name is the declared name. For an anonymous function assigned to a variable or property it is that name. Otherwise it is `<anonymous>`. The line is the function's first line.
+- `warn` and `error` are integers of at least 1; set either or both. A bare `error` or `warn` uses the default, 15. A function is reported when its score is **greater than** the limit. Any other value (0, a negative number, a fraction, a string) gives one `klint/config` warning naming the rule and the value, and that entry is ignored.
+- One diagnostic per function, at the highest level it exceeds (a function exactly at a limit does not exceed it). `error` below `warn` gives one `klint/config` warning on the rule line and the rule runs with `error` only; `error` equal to `warn` is valid and does the same.
+- A list sets limits per glob. Each entry takes `warn`, `error` and `include`. The last entry whose `include` matches a file wins; entries do not merge; a file no entry matches is not checked; an empty list turns the rule off.
+- The old `{max, severity}` form is still read with today's behaviour. In a v2 config it gives one `klint/config` warning on the rule line: ``max` and `severity` on cognitive-complexity are the old form — run `klint migrate` to upgrade it in place.`` Mixing old and new keys in one object gives one warning, and the new keys apply.
+- The message has the form ``Function `big` has cognitive complexity 16 (max 15) — split it into smaller functions.``, where `max` is the limit exceeded. The name is the declared name. For an anonymous function assigned to a variable or property it is that name. Otherwise it is `<anonymous>`. The line is the function's first line.
 - Each function starts at 0. Top-level code is not scored.
 
-**Scoring.** "Nesting" is how deep a construct sits: each enclosing `if`, loop, `switch`, `catch`, `guard`, `let … else` body and each enclosing function adds one.
+**Migrating the old form.** `klint migrate` (and `klint --fix`) rewrites the old form as follows, and `klint migrate --check` exits 1 while any of it is left:
+
+| old | new |
+|---|---|
+| `{max: M}` or `{max: M, severity: error}` | `{error: M}` |
+| `{max: M, severity: warn}` | `{warn: M}` |
+| `{max: M, severity: off}` | `off` |
+| `{severity: S}` (no `max`) | `{S: <default>}`, i.e. `{error: 15}` / `{warn: 50}`; `off` → `off` |
+| `include`, `skipBlankLines` | kept unchanged in the same object |
+
+**Scoring.** "Nesting" is how deep a construct sits: nesting is added by each enclosing `if`, loop, `switch`, `catch`, `guard` and `let … else` body; a nested function starts again at 0. Only a construct's body is nested: its condition, loop head, `switch` value or ternary test sits at the construct's own nesting. For example, in `if (a ? b : c) {}` the ternary adds 1, not 2.
 
 | Increment | TypeScript / JavaScript | Python | Swift | Rust | C# |
 |---|---|---|---|---|---|
-| +1 plus nesting: `if`, and `else if` (which also gets the nesting) | `if`, `else if` | `if`, `elif` | `if`, `else if` | `if`, `if let`, `else if` | `if`, `else if` |
+| +1 plus nesting: `if` | `if` | `if` | `if`, `if let` | `if` |
+| +1, no nesting: `else if` (its body is nested like the `if` body) | `else if` | `elif` | `else if` | `else if` | `else if` |
 | +1 plus nesting: ternary | `?:` | `x if c else y` | `?:` | — | `?:` |
 | +1 plus nesting: switch / match | `switch` | `match` | `switch` | `match` | `switch` statement, `switch` expression |
 | +1 plus nesting: loops | `for`, `for…in`, `for…of`, `while`, `do…while` | `for`, `while` | `for`, `while`, `repeat…while` | `for`, `while`, `while let`, `loop` | `for`, `foreach`, `while`, `do` |
 | +1 plus nesting: `catch` | `catch` | `except` | `catch` | — | `catch` |
 | +1 plus nesting: `guard`, `let … else` (its `else` body is nested) | — | — | `guard` | `let … else` | — |
-| +1, no nesting: `finally` (its body is not nested) | `finally` | `finally` | — | — | `finally` |
-| nesting only: nested function (scored on its own, see below) | arrow, function expression, function declaration, method | `lambda`, `def` | closure | closure | lambda, local function, anonymous method |
+| no increment: nested function (scored on its own, starting at nesting 0) | arrow, function expression, function declaration, method | `lambda`, `def` | closure | closure | lambda, local function, anonymous method |
 | +1, no nesting: plain `else` (not `else if`/`elif`) | `else` | `else` of `if`, `try`, `for`, `while` | `else` | `else` | `else` |
 | +1: labeled `break` / `continue`, `goto` | `break label`, `continue label` | — | `break label`, `continue label` | `break 'label`, `continue 'label` | `goto` |
-| +1 per logical operator, unless its direct parent is the same operator | `&&`, `\|\|`, `??` | `and`, `or` | `&&`, `\|\|`, `??` | `&&`, `\|\|` | `&&`, `\|\|`, `??`, pattern `and`, `or` |
+| +1 per run of `&&` (see below); `\|\|`, `or`, `??` add nothing | `&&` | `and` | `&&` | `&&` | `&&`, pattern `and` |
 | +1: comprehension `if` | — | comprehension `if` | — | — | — |
 | +1: guard on a case or arm | — | — | `case … where` | match-arm guard | `when` clause |
 
-Each logical operator scores +1, unless its direct parent is a logical operator of the same kind. Parentheses break that link, so a parenthesised group scores on its own: `a && b || c` is 2, `a && (b || c) && a` is 2, `a && (b && c)` is 2, and `a ?? b ?? c` is 1. Negation (`!`, `not`) adds nothing.
+Logical operators form one sequence per expression, read in source order through parentheses; negation, calls and other expressions start a new sequence. Each `&&` (`and`) scores +1 unless the operator before it in the sequence is also `&&`. `||`, `or`, `??` and pattern `or` add nothing but end a run: `a && b || c` is 1, `a && (b || c) && a` is 2, `a && (b && c)` is 1, and `a ?? b ?? c` is 0. Negation (`!`, `not`) adds nothing. In TypeScript/JavaScript, a short-circuit directly inside a JSX expression that uses one operator and has no ternary operand (`{a && <X/>}`, `{a && b && <X/>}`) adds nothing; a mixed one (`{a && b || <X/>}`) is counted as usual. A function used as a branch of a conditional expression (`a ? () => {…} : b` in TypeScript/JavaScript and C#, a Swift closure in a ternary, `(lambda: …) if a else b` in Python) is scored on its own from nesting 0 like any nested function, and every later construct in the enclosing function that adds "plus nesting" in the table above scores one more.
+
+It adds nothing for `try` itself, `finally`, `return`, `throw`, recursion, Rust `?`, Python `with`, Swift `do` without `catch`, an `if let` or `while let` beyond the `if` or `while`, optional chaining `?.`, assignment operators `||=`, `&&=`, `??=`, and a Rust `let` without `else`.
 
-It adds nothing for `try` itself, `return`, `throw`, recursion, Rust `?`, Python `with`, Swift `do` without `catch`, an `if let` or `while let` beyond the `if` or `while`, optional chaining `?.`, assignment operators `||=`, `&&=`, `??=`, and a Rust `let` without `else`.
+**Differences from the Sonar paper.** SonarJS, and so klint, departs from the 2017 paper in one place: `||` (Python `or`, C# pattern `or`) adds nothing; the paper counts it.
 
-**Differences from the Sonar paper.** This rule follows Biome, which differs from the paper in these places:
+**Differences from Biome 2.6.5.** Biome's `noExcessiveCognitiveComplexity` differs from SonarJS in four ways, and klint follows SonarJS:
 
-- `else if` gets the nesting increment.
-- `finally` adds one and does not nest its body.
-- `??` counts as a boolean operator.
-- A logical operator is scored unless its direct parent is the same operator, so `a && (b && c)` is 2, not 1.
-- Recursion adds nothing.
-- Biome 2.6.5 lowers the nesting level of the code after a plain `else` (an unbalanced decrement), so it can score such functions lower; klint keeps the nesting.
-- A nested function (closure, lambda, arrow, local function) is scored and reported on its own. It starts at its enclosing nesting level plus one and does not add to the outer function.
+- `else if` gets no nesting increment (Biome adds it).
+- `??` adds nothing (Biome counts it).
+- `||` adds nothing (Biome counts it).
+- Biome 2.6.5 lowers the nesting level of the code after a plain `else` (an unbalanced decrement). That is a Biome bug; klint keeps the nesting.
+
+A nested function (closure, lambda, arrow, local function) is scored and reported on its own and does not add to the outer function.
 
 **What counts as a function.** TypeScript/JavaScript: `function` declarations and expressions, arrow functions, methods (including getters and setters), generator functions. Python: `def` and `lambda`. Swift: `func`, `init`, `deinit`, closures, computed getters and setters. Rust: `fn` items and closures. C#: methods, constructors, destructors, local functions, lambdas, anonymous methods, property and indexer accessors, operators and conversion operators.
 
@@ -859,7 +878,7 @@ It adds nothing for `try` itself, `return`, `throw`, recursion, Rust `?`, Python
 
 ### Function length
 
-`function-length` reports every function whose body has more than `max` lines, in TypeScript/JavaScript, Python, Swift, Rust and C#. It is opt-in and has no fix. It counts with Biome 2.6.5's `noExcessiveLinesPerFunction` algorithm in every language, so a TypeScript function gets the same count as in Biome.
+`function-length` reports every function whose body has more lines than its `warn` or `error` limit, in TypeScript/JavaScript, Python, Swift, Rust and C#. It is opt-in and has no fix. It counts with Biome 2.6.5's `noExcessiveLinesPerFunction` algorithm in every language, so a TypeScript function gets the same count as in Biome.
 
 ```yaml
 rules:
@@ -867,19 +886,36 @@ rules:
     function-length: error
 ```
 
+```yaml
+rules:
+  core:
+    function-length: {warn: 60, error: 80, skipBlankLines: true}
+```
+
 ```yaml
 rules:
   core:
     function-length:
-      severity: warn
-      include: ["src/**", "!src/generated/**"]
-      max: 40
-      skipBlankLines: true
+      - {error: 50}
+      - {warn: 60, error: 80, include: ["scripts/**"]}
 ```
 
-- `max` is an integer of at least 1, default 50. A function is reported when its count is **greater than** `max`. Any other value (0, a negative number, a fraction, a string) gives one `klint/config` warning naming the rule and the value, and the rule uses 50.
+- `warn` and `error` are integers of at least 1; set either or both. A bare `error` or `warn` uses the default, 50. A function is reported when its count is **greater than** the limit. Any other value (0, a negative number, a fraction, a string) gives one `klint/config` warning naming the rule and the value, and that entry is ignored.
+- One diagnostic per function, at the highest level it exceeds (a function exactly at a limit does not exceed it). `error` below `warn` gives one `klint/config` warning on the rule line and the rule runs with `error` only; `error` equal to `warn` is valid and does the same.
+- A list sets limits per glob. Each entry takes `warn`, `error`, `include` and `skipBlankLines`. The last entry whose `include` matches a file wins; entries do not merge; a file no entry matches is not checked; an empty list turns the rule off.
+- The old `{max, severity}` form is still read with today's behaviour. In a v2 config it gives one `klint/config` warning on the rule line: ``max` and `severity` on function-length are the old form — run `klint migrate` to upgrade it in place.`` Mixing old and new keys in one object gives one warning, and the new keys apply.
 - `skipBlankLines` is a boolean, default `false`. Any other value gives one `klint/config` warning naming the rule and the value, and the rule uses `false`.
-- The message has the form ``Function `big` has 51 lines (max 50) — split it into smaller functions.``. The name is the declared name, the same rule as `cognitive-complexity`. The line is the function's first line.
+- The message has the form ``Function `big` has 51 lines (max 50) — split it into smaller functions.``, where `max` is the limit exceeded. The name is the declared name, the same rule as `cognitive-complexity`. The line is the function's first line.
+
+**Migrating the old form.** `klint migrate` (and `klint --fix`) rewrites the old form as follows, and `klint migrate --check` exits 1 while any of it is left:
+
+| old | new |
+|---|---|
+| `{max: M}` or `{max: M, severity: error}` | `{error: M}` |
+| `{max: M, severity: warn}` | `{warn: M}` |
+| `{max: M, severity: off}` | `off` |
+| `{severity: S}` (no `max`) | `{S: <default>}`, i.e. `{error: 15}` / `{warn: 50}`; `off` → `off` |
+| `include`, `skipBlankLines` | kept unchanged in the same object |
 
 **Counting.** Only the body counts, not the signature line, decorators or attributes. Every line break before a token in the body counts, except a break before `{` or `}`, so lines that hold only braces (and `};`) do not count. Comment lines and blank lines count. With `skipBlankLines`, a run of blank lines adds nothing beyond the line it leads to. A multi-line string or template counts once. Blank lines before the closing brace do not count. A nested function's lines count toward its parent, and the nested function is also checked on its own. Python counts each statement's line (there are no braces), and docstrings count.
 

package/klint.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v1.4.0/klint.schema.json",
+  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v1.5.0/klint.schema.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "additionalProperties": false,
   "description": "klint configuration. Lives at klint.yaml (or klint.config.json) next to biome.json and knip.json.",
@@ -744,8 +744,30 @@
                     },
                     {
                       "additionalProperties": false,
-                      "description": "Rule options object. Omit severity to default to \"error\". Add include to scope the rule to specific files.",
+                      "allOf": [
+                        {
+                          "anyOf": [
+                            {
+                              "required": [
+                                "warn"
+                              ]
+                            },
+                            {
+                              "required": [
+                                "error"
+                              ]
+                            }
+                          ]
+                        }
+                      ],
+                      "description": "warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.",
                       "properties": {
+                        "error": {
+                          "description": "Report a function above this limit as an error. If error is below warn, only error applies.",
+                          "format": "uint32",
+                          "minimum": 1,
+                          "type": "integer"
+                        },
                         "include": {
                           "description": "Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: [\"src/hooks/**\", \"!src/hooks/scripts/**\"]",
                           "items": {
@@ -753,31 +775,67 @@
                           },
                           "type": "array"
                         },
-                        "max": {
-                          "default": 15,
-                          "description": "Highest cognitive complexity a function may have; a function scoring above it is reported. An integer of at least 1. Defaults to 15.",
+                        "warn": {
+                          "description": "Report a function above this limit as a warning.",
                           "format": "uint32",
                           "minimum": 1,
                           "type": "integer"
-                        },
-                        "severity": {
-                          "description": "Rule severity. \"error\" exits with code 2; \"warn\" reports but exits 0; \"off\" silences.",
-                          "enum": [
-                            "error",
-                            "warn",
-                            "off",
-                            null
-                          ],
-                          "type": "string"
                         }
                       },
                       "type": "object"
+                    },
+                    {
+                      "description": "Per-glob limits: the last entry whose include matches a file wins; entries do not merge. An empty list turns the rule off.",
+                      "items": {
+                        "additionalProperties": false,
+                        "allOf": [
+                          {
+                            "anyOf": [
+                              {
+                                "required": [
+                                  "warn"
+                                ]
+                              },
+                              {
+                                "required": [
+                                  "error"
+                                ]
+                              }
+                            ]
+                          }
+                        ],
+                        "description": "warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.",
+                        "properties": {
+                          "error": {
+                            "description": "Report a function above this limit as an error. If error is below warn, only error applies.",
+                            "format": "uint32",
+                            "minimum": 1,
+                            "type": "integer"
+                          },
+                          "include": {
+                            "description": "Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: [\"src/hooks/**\", \"!src/hooks/scripts/**\"]",
+                            "items": {
+                              "type": "string"
+                            },
+                            "type": "array"
+                          },
+                          "warn": {
+                            "description": "Report a function above this limit as a warning.",
+                            "format": "uint32",
+                            "minimum": 1,
+                            "type": "integer"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "type": "array"
                     }
                   ],
-                  "description": "Reports every function whose cognitive complexity is above `max` (default 15), scored like Biome 2.6.5's `noExcessiveCognitiveComplexity` (the SonarSource Cognitive Complexity model). Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
+                  "description": "Reports every function whose cognitive complexity is above a limit, scored like `eslint-plugin-sonarjs` 3.0.5's `cognitive-complexity` (SonarSource rule S3776). Set `warn` and/or `error` limits (bare `error`/`warn` uses 15); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include}` entries sets limits per glob, and the last entry whose include matches a file wins. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
                   "examples": [
                     "cognitive-complexity: error",
-                    "cognitive-complexity:\n  severity: warn\n  include: [\"src/**\", \"!src/generated/**\"]\n  max: 14"
+                    "cognitive-complexity: {warn: 10, error: 20}",
+                    "cognitive-complexity:\n  - {error: 15}\n  - {warn: 10, error: 20, include: [\"scripts/**\"]}"
                   ]
                 },
                 "function-length": {
@@ -793,8 +851,30 @@
                     },
                     {
                       "additionalProperties": false,
-                      "description": "Rule options object. Omit severity to default to \"error\". Add include to scope the rule to specific files.",
+                      "allOf": [
+                        {
+                          "anyOf": [
+                            {
+                              "required": [
+                                "warn"
+                              ]
+                            },
+                            {
+                              "required": [
+                                "error"
+                              ]
+                            }
+                          ]
+                        }
+                      ],
+                      "description": "warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.",
                       "properties": {
+                        "error": {
+                          "description": "Report a function above this limit as an error. If error is below warn, only error applies.",
+                          "format": "uint32",
+                          "minimum": 1,
+                          "type": "integer"
+                        },
                         "include": {
                           "description": "Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: [\"src/hooks/**\", \"!src/hooks/scripts/**\"]",
                           "items": {
@@ -802,36 +882,77 @@
                           },
                           "type": "array"
                         },
-                        "max": {
-                          "default": 50,
-                          "description": "Highest number of lines a function body may have; a function counting more is reported. An integer of at least 1. Defaults to 50.",
-                          "format": "uint32",
-                          "minimum": 1,
-                          "type": "integer"
-                        },
-                        "severity": {
-                          "description": "Rule severity. \"error\" exits with code 2; \"warn\" reports but exits 0; \"off\" silences.",
-                          "enum": [
-                            "error",
-                            "warn",
-                            "off",
-                            null
-                          ],
-                          "type": "string"
-                        },
                         "skipBlankLines": {
                           "default": false,
                           "description": "Leave blank lines out of the count. Defaults to false.",
                           "type": "boolean"
+                        },
+                        "warn": {
+                          "description": "Report a function above this limit as a warning.",
+                          "format": "uint32",
+                          "minimum": 1,
+                          "type": "integer"
                         }
                       },
                       "type": "object"
+                    },
+                    {
+                      "description": "Per-glob limits: the last entry whose include matches a file wins; entries do not merge. An empty list turns the rule off.",
+                      "items": {
+                        "additionalProperties": false,
+                        "allOf": [
+                          {
+                            "anyOf": [
+                              {
+                                "required": [
+                                  "warn"
+                                ]
+                              },
+                              {
+                                "required": [
+                                  "error"
+                                ]
+                              }
+                            ]
+                          }
+                        ],
+                        "description": "warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.",
+                        "properties": {
+                          "error": {
+                            "description": "Report a function above this limit as an error. If error is below warn, only error applies.",
+                            "format": "uint32",
+                            "minimum": 1,
+                            "type": "integer"
+                          },
+                          "include": {
+                            "description": "Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: [\"src/hooks/**\", \"!src/hooks/scripts/**\"]",
+                            "items": {
+                              "type": "string"
+                            },
+                            "type": "array"
+                          },
+                          "skipBlankLines": {
+                            "default": false,
+                            "description": "Leave blank lines out of the count. Defaults to false.",
+                            "type": "boolean"
+                          },
+                          "warn": {
+                            "description": "Report a function above this limit as a warning.",
+                            "format": "uint32",
+                            "minimum": 1,
+                            "type": "integer"
+                          }
+                        },
+                        "type": "object"
+                      },
+                      "type": "array"
                     }
                   ],
-                  "description": "Reports every function whose body has more than `max` lines (default 50), counted like Biome 2.6.5's `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function's lines count toward its parent. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
+                  "description": "Reports every function whose body has more lines than a limit, counted like Biome 2.6.5's `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function's lines count toward its parent. Set `warn` and/or `error` limits (bare `error`/`warn` uses 50); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include, skipBlankLines}` entries sets limits per glob, and the last entry whose include matches a file wins. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
                   "examples": [
                     "function-length: error",
-                    "function-length:\n  severity: warn\n  include: [\"src/**\", \"!src/generated/**\"]\n  max: 40\n  skipBlankLines: true"
+                    "function-length: {warn: 60, error: 80, skipBlankLines: true}",
+                    "function-length:\n  - {error: 50}\n  - {warn: 60, error: 80, include: [\"scripts/**\"]}"
                   ]
                 },
                 "no-async-predicate": {
@@ -1591,10 +1712,11 @@
                   "type": "object"
                 }
               ],
-              "description": "Reports every function whose cognitive complexity is above `max` (default 15), scored like Biome 2.6.5's `noExcessiveCognitiveComplexity` (the SonarSource Cognitive Complexity model). Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
+              "description": "Reports every function whose cognitive complexity is above a limit, scored like `eslint-plugin-sonarjs` 3.0.5's `cognitive-complexity` (SonarSource rule S3776). Set `warn` and/or `error` limits (bare `error`/`warn` uses 15); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include}` entries sets limits per glob, and the last entry whose include matches a file wins. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
               "examples": [
                 "cognitive-complexity: error",
-                "cognitive-complexity:\n  severity: warn\n  include: [\"src/**\", \"!src/generated/**\"]\n  max: 14"
+                "cognitive-complexity: {warn: 10, error: 20}",
+                "cognitive-complexity:\n  - {error: 15}\n  - {warn: 10, error: 20, include: [\"scripts/**\"]}"
               ]
             },
             "function-length": {
@@ -1645,10 +1767,11 @@
                   "type": "object"
                 }
               ],
-              "description": "Reports every function whose body has more than `max` lines (default 50), counted like Biome 2.6.5's `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function's lines count toward its parent. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
+              "description": "Reports every function whose body has more lines than a limit, counted like Biome 2.6.5's `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function's lines count toward its parent. Set `warn` and/or `error` limits (bare `error`/`warn` uses 50); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include, skipBlankLines}` entries sets limits per glob, and the last entry whose include matches a file wins. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.",
               "examples": [
                 "function-length: error",
-                "function-length:\n  severity: warn\n  include: [\"src/**\", \"!src/generated/**\"]\n  max: 40\n  skipBlankLines: true"
+                "function-length: {warn: 60, error: 80, skipBlankLines: true}",
+                "function-length:\n  - {error: 50}\n  - {warn: 60, error: 80, include: [\"scripts/**\"]}"
               ]
             },
             "no-async-predicate": {

package/klint.schema.yaml

@@ -1,4 +1,4 @@
-$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v1.4.0/klint.schema.json
+$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v1.5.0/klint.schema.json
 $schema: http://json-schema.org/draft-07/schema#
 additionalProperties: false
 description: klint configuration. Lives at klint.yaml (or klint.config.json) next to biome.json and knip.json.
@@ -566,36 +566,66 @@ properties:
                 - off
                 type: string
               - additionalProperties: false
-                description: Rule options object. Omit severity to default to "error". Add include to scope the rule to specific files.
+                allOf:
+                - anyOf:
+                  - required:
+                    - warn
+                  - required:
+                    - error
+                description: warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.
                 properties:
+                  error:
+                    description: Report a function above this limit as an error. If error is below warn, only error applies.
+                    format: uint32
+                    minimum: 1
+                    type: integer
                   include:
                     description: 'Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: ["src/hooks/**", "!src/hooks/scripts/**"]'
                     items:
                       type: string
                     type: array
-                  max:
-                    default: 15
-                    description: Highest cognitive complexity a function may have; a function scoring above it is reported. An integer of at least 1. Defaults to 15.
+                  warn:
+                    description: Report a function above this limit as a warning.
                     format: uint32
                     minimum: 1
                     type: integer
-                  severity:
-                    description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.
-                    enum:
-                    - error
-                    - warn
-                    - off
-                    - null
-                    type: string
                 type: object
-              description: Reports every function whose cognitive complexity is above `max` (default 15), scored like Biome 2.6.5's `noExcessiveCognitiveComplexity` (the SonarSource Cognitive Complexity model). Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.
+              - description: 'Per-glob limits: the last entry whose include matches a file wins; entries do not merge. An empty list turns the rule off.'
+                items:
+                  additionalProperties: false
+                  allOf:
+                  - anyOf:
+                    - required:
+                      - warn
+                    - required:
+                      - error
+                  description: warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.
+                  properties:
+                    error:
+                      description: Report a function above this limit as an error. If error is below warn, only error applies.
+                      format: uint32
+                      minimum: 1
+                      type: integer
+                    include:
+                      description: 'Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: ["src/hooks/**", "!src/hooks/scripts/**"]'
+                      items:
+                        type: string
+                      type: array
+                    warn:
+                      description: Report a function above this limit as a warning.
+                      format: uint32
+                      minimum: 1
+                      type: integer
+                  type: object
+                type: array
+              description: Reports every function whose cognitive complexity is above a limit, scored like `eslint-plugin-sonarjs` 3.0.5's `cognitive-complexity` (SonarSource rule S3776). Set `warn` and/or `error` limits (bare `error`/`warn` uses 15); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include}` entries sets limits per glob, and the last entry whose include matches a file wins. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.
               examples:
               - 'cognitive-complexity: error'
+              - 'cognitive-complexity: {warn: 10, error: 20}'
               - |-
                 cognitive-complexity:
-                  severity: warn
-                  include: ["src/**", "!src/generated/**"]
-                  max: 14
+                  - {error: 15}
+                  - {warn: 10, error: 20, include: ["scripts/**"]}
             function-length:
               anyOf:
               - description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.
@@ -605,41 +635,74 @@ properties:
                 - off
                 type: string
               - additionalProperties: false
-                description: Rule options object. Omit severity to default to "error". Add include to scope the rule to specific files.
+                allOf:
+                - anyOf:
+                  - required:
+                    - warn
+                  - required:
+                    - error
+                description: warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.
                 properties:
+                  error:
+                    description: Report a function above this limit as an error. If error is below warn, only error applies.
+                    format: uint32
+                    minimum: 1
+                    type: integer
                   include:
                     description: 'Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: ["src/hooks/**", "!src/hooks/scripts/**"]'
                     items:
                       type: string
                     type: array
-                  max:
-                    default: 50
-                    description: Highest number of lines a function body may have; a function counting more is reported. An integer of at least 1. Defaults to 50.
-                    format: uint32
-                    minimum: 1
-                    type: integer
-                  severity:
-                    description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.
-                    enum:
-                    - error
-                    - warn
-                    - off
-                    - null
-                    type: string
                   skipBlankLines:
                     default: false
                     description: Leave blank lines out of the count. Defaults to false.
                     type: boolean
+                  warn:
+                    description: Report a function above this limit as a warning.
+                    format: uint32
+                    minimum: 1
+                    type: integer
                 type: object
-              description: 'Reports every function whose body has more than `max` lines (default 50), counted like Biome 2.6.5''s `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function''s lines count toward its parent. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.'
+              - description: 'Per-glob limits: the last entry whose include matches a file wins; entries do not merge. An empty list turns the rule off.'
+                items:
+                  additionalProperties: false
+                  allOf:
+                  - anyOf:
+                    - required:
+                      - warn
+                    - required:
+                      - error
+                  description: warn and/or error limits. A function gets one diagnostic, at the highest level it exceeds.
+                  properties:
+                    error:
+                      description: Report a function above this limit as an error. If error is below warn, only error applies.
+                      format: uint32
+                      minimum: 1
+                      type: integer
+                    include:
+                      description: 'Glob patterns scoping this rule to a subset of files. Prefix with ! to exclude. Example: ["src/hooks/**", "!src/hooks/scripts/**"]'
+                      items:
+                        type: string
+                      type: array
+                    skipBlankLines:
+                      default: false
+                      description: Leave blank lines out of the count. Defaults to false.
+                      type: boolean
+                    warn:
+                      description: Report a function above this limit as a warning.
+                      format: uint32
+                      minimum: 1
+                      type: integer
+                  type: object
+                type: array
+              description: 'Reports every function whose body has more lines than a limit, counted like Biome 2.6.5''s `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function''s lines count toward its parent. Set `warn` and/or `error` limits (bare `error`/`warn` uses 50); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include, skipBlankLines}` entries sets limits per glob, and the last entry whose include matches a file wins. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.'
               examples:
               - 'function-length: error'
+              - 'function-length: {warn: 60, error: 80, skipBlankLines: true}'
               - |-
                 function-length:
-                  severity: warn
-                  include: ["src/**", "!src/generated/**"]
-                  max: 40
-                  skipBlankLines: true
+                  - {error: 50}
+                  - {warn: 60, error: 80, include: ["scripts/**"]}
             no-async-predicate:
               anyOf:
               - description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.
@@ -1176,14 +1239,14 @@ properties:
                 - null
                 type: string
             type: object
-          description: Reports every function whose cognitive complexity is above `max` (default 15), scored like Biome 2.6.5's `noExcessiveCognitiveComplexity` (the SonarSource Cognitive Complexity model). Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.
+          description: Reports every function whose cognitive complexity is above a limit, scored like `eslint-plugin-sonarjs` 3.0.5's `cognitive-complexity` (SonarSource rule S3776). Set `warn` and/or `error` limits (bare `error`/`warn` uses 15); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include}` entries sets limits per glob, and the last entry whose include matches a file wins. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.
           examples:
           - 'cognitive-complexity: error'
+          - 'cognitive-complexity: {warn: 10, error: 20}'
           - |-
             cognitive-complexity:
-              severity: warn
-              include: ["src/**", "!src/generated/**"]
-              max: 14
+              - {error: 15}
+              - {warn: 10, error: 20, include: ["scripts/**"]}
         function-length:
           anyOf:
           - description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.
@@ -1219,15 +1282,14 @@ properties:
                 description: Leave blank lines out of the count. Defaults to false.
                 type: boolean
             type: object
-          description: 'Reports every function whose body has more than `max` lines (default 50), counted like Biome 2.6.5''s `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function''s lines count toward its parent. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.'
+          description: 'Reports every function whose body has more lines than a limit, counted like Biome 2.6.5''s `noExcessiveLinesPerFunction`: brace lines do not count, comment and blank lines do (blank lines not with `skipBlankLines`), and a nested function''s lines count toward its parent. Set `warn` and/or `error` limits (bare `error`/`warn` uses 50); a function gets one diagnostic, at the highest level it exceeds. A list of `{warn, error, include, skipBlankLines}` entries sets limits per glob, and the last entry whose include matches a file wins. Getters and setters are not checked. Works on TypeScript/JavaScript, Python, Swift, Rust and C#. Opt-in; no autofix.'
           examples:
           - 'function-length: error'
+          - 'function-length: {warn: 60, error: 80, skipBlankLines: true}'
           - |-
             function-length:
-              severity: warn
-              include: ["src/**", "!src/generated/**"]
-              max: 40
-              skipBlankLines: true
+              - {error: 50}
+              - {warn: 60, error: 80, include: ["scripts/**"]}
         no-async-predicate:
           anyOf:
           - description: Rule severity. "error" exits with code 2; "warn" reports but exits 0; "off" silences.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -56,12 +56,12 @@
     ]
   },
   "optionalDependencies": {
-    "@konvert7/klint-darwin-arm64": "1.4.0",
-    "@konvert7/klint-darwin-x64": "1.4.0",
-    "@konvert7/klint-linux-arm64": "1.4.0",
-    "@konvert7/klint-linux-x64": "1.4.0",
-    "@konvert7/klint-linux-x64-musl": "1.4.0",
-    "@konvert7/klint-win32-x64": "1.4.0"
+    "@konvert7/klint-darwin-arm64": "1.5.0",
+    "@konvert7/klint-darwin-x64": "1.5.0",
+    "@konvert7/klint-linux-arm64": "1.5.0",
+    "@konvert7/klint-linux-x64": "1.5.0",
+    "@konvert7/klint-linux-x64-musl": "1.5.0",
+    "@konvert7/klint-win32-x64": "1.5.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.6.5",
@@ -72,6 +72,9 @@
     "@semantic-release/github": "^12.0.6",
     "@types/bun": "latest",
     "@types/node": "latest",
+    "@typescript-eslint/parser": "8.72.2",
+    "eslint": "9.39.5",
+    "eslint-plugin-sonarjs": "3.0.5",
     "husky": "^9.1.7",
     "jscpd": "4.2.3",
     "knip": "^6.9.0",