feat: add rust-max-lines hook

Built-in shell hook that fails when a Rust source file exceeds a
configurable line-count ceiling. Default --max=1000; counts total file
lines via wc -l, no Rust toolchain required. Scoped to types: [rust].

Also escapes the C# heading anchor so the rumdl markdown formatter
stops eating the trailing #.

Author: Goldziher

.pre-commit-hooks.yaml

@@ -254,6 +254,14 @@
   pass_filenames: false
   args: []
 
+- id: rust-max-lines
+  name: rust-max-lines (Rust file line-count ceiling)
+  description: Fail when a Rust source file exceeds the configured line-count ceiling.
+  entry: hooks/rust-max-lines/run.sh
+  language: script
+  types: [rust]
+  args: ["--max=1000"]
+
 - id: gleam-format
   name: gleam format
   description: Format Gleam source files using the project's installed gleam toolchain.

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-06-06
+
+### Added
+
+- `rust-max-lines`: new built-in hook that fails when a Rust source file
+  exceeds a configurable line-count ceiling. Default `--max=1000`; pure shell
+  via `wc -l`, no Rust toolchain required. Scoped to `types: [rust]`.
+  (`hooks/rust-max-lines/run.sh`)
+
 ## [1.2.4] - 2026-06-04
 
 ### Fixed

README.md

@@ -81,6 +81,7 @@ Each hook falls into one of four implementation categories:
 | `cargo-machete` | Detect unused Rust dependencies | Toolchain wrapper (pinned) |
 | `cargo-deny` | Check Rust dependency advisories and licenses | Toolchain wrapper (pinned) |
 | `rustdoc-lint` | Check Rust documentation completeness (v1.1.0+) | Toolchain wrapper |
+| `rust-max-lines` | Fail when a Rust file exceeds a line-count ceiling (default 1000) | Built-in |
 
 ### Python
 
@@ -130,7 +131,7 @@ Each hook falls into one of four implementation categories:
 | `steep` | Type-check Ruby projects | Toolchain wrapper |
 | `yard-coverage` | Check Ruby YARD documentation coverage (v1.1.0+) | Toolchain wrapper |
 
-### C#
+### C\#
 
 | Hook | Purpose | Category |
 |---|---|---|
@@ -276,12 +277,14 @@ All doc hooks are opt-in — they complement linting/formatting hooks but are mo
 Use this table to copy-paste a language block into your `.pre-commit-config.yaml`:
 
 **Shell:**
+
 ```yaml
 - id: shfmt
 - id: shellcheck
 ```
 
 **Rust:**
+
 ```yaml
 - id: cargo-fmt
 - id: cargo-check
@@ -290,15 +293,18 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 - id: cargo-machete
 - id: cargo-deny
 - id: rustdoc-lint
+- id: rust-max-lines
 ```
 
 **Python:**
+
 ```yaml
 - id: mypy
 - id: pydocstyle
 ```
 
 **Go:**
+
 ```yaml
 - id: go-fmt
 - id: golangci-lint
@@ -307,18 +313,21 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 ```
 
 **TypeScript:**
+
 ```yaml
 - id: tsc-typecheck
 - id: tsdoc-lint
 ```
 
 **JavaScript/TypeScript (formatting):**
+
 ```yaml
 - id: oxlint
 - id: oxfmt
 ```
 
 **Java:**
+
 ```yaml
 - id: palantir-java-format
 - id: checkstyle
@@ -328,6 +337,7 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 ```
 
 **Kotlin:**
+
 ```yaml
 - id: ktfmt
 - id: detekt
@@ -336,6 +346,7 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 ```
 
 **Ruby:**
+
 ```yaml
 - id: rubocop
 - id: rubocop-lint
@@ -344,27 +355,31 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 ```
 
 **C#:**
+
 ```yaml
 - id: dotnet-format
 - id: dotnet-format-check
 - id: cs-xmldoc-lint
 ```
 
 **PHP:**
+
 ```yaml
 - id: php-cs-fixer
 - id: phpstan
 - id: phpdoc-lint
 ```
 
 **Elixir:**
+
 ```yaml
 - id: mix-format
 - id: mix-credo
 - id: ex-doc-coverage
 ```
 
 **R:**
+
 ```yaml
 - id: air-format
 - id: air-check
@@ -373,58 +388,67 @@ Use this table to copy-paste a language block into your `.pre-commit-config.yaml
 ```
 
 **Swift:**
+
 ```yaml
 - id: swift-format
 - id: swiftlint
 - id: swift-doc-coverage
 ```
 
 **Dart:**
+
 ```yaml
 - id: dart-format
 - id: dart-analyze
 - id: dart-doc-lint
 ```
 
 **Zig:**
+
 ```yaml
 - id: zig-fmt
 - id: zig-build-check
 - id: zig-doc-lint
 ```
 
 **Gleam:**
+
 ```yaml
 - id: gleam-format
 - id: gleam-check
 ```
 
 **C/C++:**
+
 ```yaml
 - id: clang-format
 - id: clang-tidy
 - id: cppcheck
 ```
 
 **Docker:**
+
 ```yaml
 - id: hadolint
 ```
 
 **Helm/Kubernetes:**
+
 ```yaml
 - id: helm-lint
 - id: kubeconform
 ```
 
 **Markdown:**
+
 ```yaml
 - id: rumdl-fmt
 - id: markdownlint-rumdl-strict
 - id: textlint
 ```
 
 **Polyglot (Alef):**
+
 ```yaml
 - id: alef-docs-fresh
 ```
@@ -454,7 +478,7 @@ CI tests against `ubuntu-latest`, `macos-latest`, `windows-latest` × Python 3.1
 
 ## Cache layout
 
-```
+```text
 ${KREUZBERG_HOOKS_CACHE:-$HOME/.cache/kreuzberg-pre-commit-hooks}/<tool>/<version>/<arch>/
 ```
 

docs/hooks/rust-max-lines.md

@@ -0,0 +1,30 @@
+# rust-max-lines
+
+Fail when a Rust source file exceeds a configurable line-count ceiling.
+
+This hook is check-only.
+
+## Configuration
+
+```yaml
+- id: rust-max-lines
+  args: ["--max=1000"]
+```
+
+Override the ceiling per repo:
+
+```yaml
+- id: rust-max-lines
+  args: ["--max=1500"]
+```
+
+`N` must be a positive integer; any other value exits with status 2.
+
+## Counting method
+
+Total file lines via `wc -l` — blanks and comments included. Pure shell, no
+Rust toolchain required.
+
+## Implementation
+
+Built-in shell hook. Source: `hooks/rust-max-lines/run.sh`.

hooks/rust-max-lines/README.md

@@ -0,0 +1,33 @@
+# rust-max-lines
+
+Fail when a Rust source file exceeds a configurable line-count ceiling. Pure
+shell — no external toolchain required.
+
+## Category
+
+Built-in. The hook counts total file lines (including blanks and comments) via
+`wc -l` and exits non-zero when any staged `.rs` file is above the threshold.
+
+## Default args
+
+`--max=1000` — files with more than 1000 lines fail the hook. Override per repo:
+
+```yaml
+- id: rust-max-lines
+  args: ["--max=1500"]
+```
+
+Only `--max=N` is accepted. `N` must be a positive integer.
+
+## Why total lines
+
+Counting raw file length avoids parser complexity and gives a deterministic
+signal that's easy to reason about in PR review. If you want stricter "code
+only" metrics, pair with `cargo-clippy` cognitive-complexity lints.
+
+## Troubleshooting
+
+- `rust-max-lines: --max must be a positive integer` — the configured `--max`
+  value is non-numeric or zero. Use `args: ["--max=1000"]` form.
+- File exceeds limit — split the module into focused submodules; in Rust this
+  is usually a sign one type is doing too much.

hooks/rust-max-lines/run.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# rust-max-lines — fail when any staged Rust source exceeds the configured
+# line-count ceiling. Counts total file lines (including blanks and comments)
+# via `wc -l`, which is fast and parser-free.
+#
+# Configuration:
+#   args: ["--max=<N>"]   default 1000
+#
+# All non-flag arguments are treated as file paths supplied by pre-commit.
+set -euo pipefail
+
+MAX_LINES=1000
+files=()
+
+for arg in "$@"; do
+  case "$arg" in
+  --max=*)
+    MAX_LINES="${arg#--max=}"
+    ;;
+  --max)
+    printf 'rust-max-lines: --max requires "=N" form (e.g. --max=1000)\n' >&2
+    exit 2
+    ;;
+  --*)
+    printf 'rust-max-lines: unknown flag %q\n' "$arg" >&2
+    exit 2
+    ;;
+  *)
+    files+=("$arg")
+    ;;
+  esac
+done
+
+if ! [[ "$MAX_LINES" =~ ^[1-9][0-9]*$ ]]; then
+  printf 'rust-max-lines: --max must be a positive integer, got %q\n' "$MAX_LINES" >&2
+  exit 2
+fi
+
+if [[ ${#files[@]} -eq 0 ]]; then
+  exit 0
+fi
+
+status=0
+for file in "${files[@]}"; do
+  if [[ ! -f "$file" ]]; then
+    continue
+  fi
+  lines=$(wc -l <"$file" | tr -d '[:space:]')
+  if ((lines > MAX_LINES)); then
+    printf '%s: %d lines exceeds limit of %d\n' "$file" "$lines" "$MAX_LINES" >&2
+    status=1
+  fi
+done
+
+exit "$status"