@konvert7/klint 0.31.0 → 0.32.0

package/README.md

@@ -446,7 +446,7 @@ arch:
       in: ["src/**"]
 ```
 
-Set `countDocComments: true` on either rule to count doc-comments toward the limit as well. Both rules run in the TS and Rust engines; Python (`#`) and Swift (`//`, `/* */`) files are enforced by the Rust engine.
+Set `countDocComments: true` on either rule to count doc-comments toward the limit as well. Both rules run in the TS and Rust engines; Python (`#`), Swift (`//`, `/* */`), and C# (`//`, `/* */`) files are enforced by the Rust engine.
 
 Some comments are machinery rather than prose — markers a build or codegen step reads, region pragmas — and counting them makes both limits measure the wrong thing. `ignore` exempts them, on either rule:
 
@@ -462,33 +462,33 @@ An ignored line still counts in the density denominator — it is a physical lin
 
 ### Language Support
 
-klint scans TypeScript/JavaScript, Python, Swift, and Rust. Every architecture rule is enforced from the same `klint.yaml`, but what a rule can *see* depends on what the language actually has.
-
-| | TypeScript / JavaScript | Python | Swift | Rust |
-|---|---|---|---|---|
-| **Engines** | `ts`, `rust` | `rust` | `rust` | `rust` |
-| **Parser** | TypeScript compiler API (TS engine), tree-sitter (Rust engine) | tree-sitter | tree-sitter | tree-sitter |
-| `arch.imports` — static | ✅ | ✅ | ✅ | ✅ `use` |
-| `arch.imports` — dynamic | ✅ `import()` | ✅ `importlib.import_module`, `__import__` | — | — |
-| `arch.imports` — re-exports | ✅ `export … from` | — | ✅ `@_exported import` | ✅ `pub use` |
-| `arch.imports` — multi-target | — | ✅ `import a, b` | — | ✅ `use a::{b, c}` |
-| `type-only: allow` | ✅ `import type` | ✅ `if TYPE_CHECKING:` | — | — |
-| Path aliases | ✅ `tsconfig.json` `paths` | — | — | — |
-| Module resolution | relative paths + alias chains | relative, absolute, and PEP 420 namespace packages | module name against project dirs and file stems | `crate::`/`self::`/`super::` against the directory tree |
-| `deny-packages` | ✅ `/` segments | ✅ `.` segments | ✅ `.` segments, module granularity | ✅ `::` segments |
-| `arch.forbidden` / `singleton` — `pattern` | ✅ | ✅ | ✅ | ✅ |
-| `arch.forbidden` / `singleton` — `jsx-element` | ✅ | — | — | — |
-| `arch.maxLines` | ✅ | ✅ | ✅ | ✅ |
-| `arch.maxCommentDensity` / `maxCommentBlock` | ✅ `//`, `/* */`, `/** */` docs | ✅ `#` | ✅ `//`, `/* */`, `///` and `/** */` docs | ✅ `//`, `/* */`, `///` and `//!` docs |
-| Built-in rules and plugins | ✅ | ✗ | ✗ | ✗ |
-| Custom rules (`klint.rules.ts`) | ✅ | ✗ | ✗ | ✗ |
-| Type-aware rules | ✅ | ✗ | ✗ | ✗ |
+klint scans TypeScript/JavaScript, Python, Swift, Rust, and C#. Every architecture rule is enforced from the same `klint.yaml`, but what a rule can *see* depends on what the language actually has.
+
+| | TypeScript / JavaScript | Python | Swift | Rust | C# |
+|---|---|---|---|---|---|
+| **Engines** | `ts`, `rust` | `rust` | `rust` | `rust` | `rust` |
+| **Parser** | TypeScript compiler API (TS engine), tree-sitter (Rust engine) | tree-sitter | tree-sitter | tree-sitter | tree-sitter |
+| `arch.imports` — static | ✅ | ✅ | ✅ | ✅ `use` | ✅ `using` |
+| `arch.imports` — dynamic | ✅ `import()` | ✅ `importlib.import_module`, `__import__` | — | — | — |
+| `arch.imports` — re-exports | ✅ `export … from` | — | ✅ `@_exported import` | ✅ `pub use` | — |
+| `arch.imports` — multi-target | — | ✅ `import a, b` | — | ✅ `use a::{b, c}` | — |
+| `type-only: allow` | ✅ `import type` | ✅ `if TYPE_CHECKING:` | — | — | — |
+| Path aliases | ✅ `tsconfig.json` `paths` | — | — | — | — |
+| Module resolution | relative paths + alias chains | relative, absolute, and PEP 420 namespace packages | module name against project dirs and file stems | `crate::`/`self::`/`super::` against the directory tree | `using` namespace against project namespace declarations |
+| `deny-packages` | ✅ `/` segments | ✅ `.` segments | ✅ `.` segments, module granularity | ✅ `::` segments | ✅ `.` segments |
+| `arch.forbidden` / `singleton` — `pattern` | ✅ | ✅ | ✅ | ✅ | ✅ |
+| `arch.forbidden` / `singleton` — `jsx-element` | ✅ | — | — | — | — |
+| `arch.maxLines` | ✅ | ✅ | ✅ | ✅ | ✅ |
+| `arch.maxCommentDensity` / `maxCommentBlock` | ✅ `//`, `/* */`, `/** */` docs | ✅ `#` | ✅ `//`, `/* */`, `///` and `/** */` docs | ✅ `//`, `/* */`, `///` and `//!` docs | ✅ `//`, `/* */`, `///` and `/** */` docs |
+| Built-in rules and plugins | ✅ | ✗ | ✗ | ✗ | ✗ |
+| Custom rules (`klint.rules.ts`) | ✅ | ✗ | ✗ | ✗ | ✗ |
+| Type-aware rules | ✅ | ✗ | ✗ | ✗ | ✗ |
 
 **✅** supported · **—** the language has no equivalent construct · **✗** not supported yet
 
-A dash is not a gap. Swift has no dynamic import expression, no `import type`, and one module per declaration; Rust has no dynamic import and no type-only import. Those rows can never be filled. The `✗` rows are real limits: the rule set and custom rules are written against the TypeScript AST, and type-aware rules need a type checker that only the TS engine has.
+A dash is not a gap. Swift has no dynamic import expression, no `import type`, and one module per declaration; Rust has no dynamic import and no type-only import; C# has no dynamic `using`, no type-only import, and one namespace per `using`. Those rows can never be filled. The `✗` rows are real limits: the rule set and custom rules are written against the TypeScript AST, and type-aware rules need a type checker that only the TS engine has.
 
-Imports are read off the AST in every language, so a specifier written inside a comment or a string is never an import — including nested Swift block comments. Only file discovery differs: the TS engine walks `.ts`/`.tsx`/`.js`/`.jsx`/`.mts`/`.cts`, so Python, Swift, and Rust files reach klint through the Rust engine, which `auto` mode selects for them automatically.
+Imports are read off the AST in every language, so a specifier written inside a comment or a string is never an import — including nested Swift block comments. Only file discovery differs: the TS engine walks `.ts`/`.tsx`/`.js`/`.jsx`/`.mts`/`.cts`, so Python, Swift, Rust, and C# files reach klint through the Rust engine, which `auto` mode selects for them automatically.
 
 ### Python Architecture Checks
 
@@ -629,6 +629,53 @@ not a Cargo build graph or `#[path]` attribute resolver.
 Comment budget rules apply to Rust too, where both `///` and `//!` count as
 doc-comments.
 
+### C# Architecture Checks
+
+The Rust engine can apply architecture rules to C# projects:
+
+```yaml
+include: ["src"]
+
+rules: {}
+
+arch:
+  layers:
+    web: ["src/Web/**"]
+    data: ["src/Data/**"]
+    config: ["src/Config/**"]
+
+  imports:
+    - from: web
+      deny: data
+      message: "Web must use app services, not import the data layer directly"
+    - from: web
+      deny-packages: ["Newtonsoft"]
+      message: "Use System.Text.Json instead of Newtonsoft"
+
+  forbidden:
+    - pattern: "Console.WriteLine("
+      in: web
+      message: "Use the logger"
+```
+
+C# import checks read `using` declarations off the AST, covering `using System;`,
+qualified namespaces such as `using System.Collections.Generic;`, `using static
+System.Math;`, `global using System.Linq;`, and aliases such as `using Json =
+Newtonsoft.Json;` — an alias resolves to its target namespace, not the alias
+name. Because the specifier comes from the parse tree, a `using` written inside a
+`//` or `/* */` comment is not an import.
+
+C# namespaces are decoupled from disk layout, so klint indexes the `namespace`
+declarations across the project — block and file-scoped alike — and resolves a
+`using` against that index. Namespaces that no project file declares, such as
+`System`, are ignored by `deny`/`allow` and are the target of `deny-packages`
+instead, which matches on `.` segments so `Newtonsoft` denies `Newtonsoft.Json`
+but never `NewtonsoftShim`. This is architecture enforcement, not a full MSBuild
+or NuGet restore graph.
+
+Comment budget rules apply to C# too, where `///` XML doc comments count as
+doc-comments alongside `/** */`.
+
 ## Built-in Rules
 
 | Rule | Type-aware | Description |

package/core/config.schema.ts

@@ -86,7 +86,7 @@ const ArchImportRuleSchema = z
       "Allowlist of layer name(s) / glob(s) the source may import from. Anything not matching `allow` is denied."
     ),
     "deny-packages": StringOrStringArray.optional().describe(
-      "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip packages and stdlib modules, Swift system frameworks, and external Rust crates, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python and Swift, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, and Rust sources are checked by the Rust engine."
+      "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip packages and stdlib modules, Swift system frameworks, external Rust crates, and C# namespaces or NuGet packages, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python, Swift, and C#, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, Rust, and C# sources are checked by the Rust engine."
     ),
     "type-only": z
       .literal("allow")
@@ -244,7 +244,7 @@ const CountDocCommentsSchema = z
   .boolean()
   .optional()
   .describe(
-    "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit."
+    "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit."
   );
 
 const CommentIgnoreSchema = StringOrStringArray.optional().describe(

package/klint.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.31.0/klint.schema.json",
+  "$id": "https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.32.0/klint.schema.json",
   "type": "object",
   "properties": {
     "$schema": {
@@ -819,7 +819,7 @@
                 ]
               },
               "deny-packages": {
-                "description": "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip packages and stdlib modules, Swift system frameworks, and external Rust crates, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python and Swift, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, and Rust sources are checked by the Rust engine.",
+                "description": "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip packages and stdlib modules, Swift system frameworks, external Rust crates, and C# namespaces or NuGet packages, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python, Swift, and C#, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, Rust, and C# sources are checked by the Rust engine.",
                 "anyOf": [
                   {
                     "type": "string"
@@ -1141,7 +1141,7 @@
                 "description": "Maximum percentage of a file's physical lines that may be comment lines. Denominator is total physical lines (code + comments + blanks), the same count `maxLines` uses. A file above this ratio is a violation."
               },
               "countDocComments": {
-                "description": "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit.",
+                "description": "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit.",
                 "type": "boolean"
               },
               "ignore": {
@@ -1210,7 +1210,7 @@
                 "description": "Maximum number of consecutive comment lines allowed in a single block. A run of more comment lines than this — e.g. a tall comment stacked above a statement — is a violation, reported at the first offending line."
               },
               "countDocComments": {
-                "description": "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit.",
+                "description": "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python: docstrings are string expressions rather than comments, so they never count toward either limit.",
                 "type": "boolean"
               },
               "ignore": {

package/klint.schema.yaml

@@ -1,5 +1,5 @@
 $schema: http://json-schema.org/draft-07/schema#
-$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.31.0/klint.schema.json
+$id: https://raw.githubusercontent.com/konvert7/klint/refs/tags/v0.32.0/klint.schema.json
 type: object
 properties:
   $schema:
@@ -596,12 +596,12 @@ properties:
                     type: string
             deny-packages:
               description: "Package specifier(s) the source is not allowed to import — npm packages, `node:` builtins, Python pip
-                packages and stdlib modules, Swift system frameworks, and external Rust crates, which `deny`/`allow`
-                cannot reach because they never resolve to a project file. Matching is per segment: `/` in
-                TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is unaffected; `.` in Python
-                and Swift, so `os` also covers `os.path` while `oscrypto` is unaffected; and `::` in Rust, so `tokio`
-                also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python, Swift, and Rust sources are
-                checked by the Rust engine."
+                packages and stdlib modules, Swift system frameworks, external Rust crates, and C# namespaces or NuGet
+                packages, which `deny`/`allow` cannot reach because they never resolve to a project file. Matching is
+                per segment: `/` in TypeScript/JavaScript, so `next` also covers `next/headers` while `nextra` is
+                unaffected; `.` in Python, Swift, and C#, so `os` also covers `os.path` while `oscrypto` is unaffected;
+                and `::` in Rust, so `tokio` also covers `tokio::sync::Mutex` while `tokio_util` is unaffected. Python,
+                Swift, Rust, and C# sources are checked by the Rust engine."
               anyOf:
                 - type: string
                 - type: array
@@ -880,10 +880,11 @@ properties:
                 lines (code + comments + blanks), the same count `maxLines` uses. A file above this ratio is a
                 violation.
             countDocComments:
-              description: "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift), and
-                `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false,
-                so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python:
-                docstrings are string expressions rather than comments, so they never count toward either limit."
+              description: "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and
+                C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to
+                false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on
+                Python: docstrings are string expressions rather than comments, so they never count toward either
+                limit."
               type: boolean
             ignore:
               description: Comment lines matching these patterns are structural, not prose — marker comments a build or codegen step
@@ -947,10 +948,11 @@ properties:
                 this — e.g. a tall comment stacked above a statement — is a violation, reported at the first offending
                 line.
             countDocComments:
-              description: "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift), and
-                `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to false,
-                so documentation is exempt and only explanatory/inline comments are capped. Has no effect on Python:
-                docstrings are string expressions rather than comments, so they never count toward either limit."
+              description: "Count doc-comments toward the limit. Doc-comments are `/** … */` JSDoc blocks (TS/JS), `///` (Swift and
+                C#), and `///` or `//!` (Rust); ordinary `//`, `/* */`, and `#` comments are always counted. Defaults to
+                false, so documentation is exempt and only explanatory/inline comments are capped. Has no effect on
+                Python: docstrings are string expressions rather than comments, so they never count toward either
+                limit."
               type: boolean
             ignore:
               description: Comment lines matching these patterns are structural, not prose — marker comments a build or codegen step

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {
@@ -67,10 +67,10 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "@konvert7/klint-darwin-arm64": "0.31.0",
-    "@konvert7/klint-darwin-x64": "0.31.0",
-    "@konvert7/klint-linux-x64": "0.31.0",
-    "@konvert7/klint-win32-x64": "0.31.0"
+    "@konvert7/klint-darwin-arm64": "0.32.0",
+    "@konvert7/klint-darwin-x64": "0.32.0",
+    "@konvert7/klint-linux-x64": "0.32.0",
+    "@konvert7/klint-win32-x64": "0.32.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.7",