litclaude-ai 0.2.2

package/plugins/litclaude/skills/programming/scripts/python/check-no-excuse-rules.py

@@ -0,0 +1,687 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+# noqa: SIZE_OK  — single self-contained checker, splitting adds import ceremony for no readability gain
+"""Check Python files for no-excuse violations.
+
+The python-programmer skill enforces these rules. Run after editing.
+
+Rules:
+  cast-any             - cast(Any, ...) / cast(typing.Any, ...) / typing.cast(Any, ...)
+  type-ignore          - `# type: ignore` comments (any variant)
+  pyright-ignore       - `# pyright: ignore` comments (any variant)
+  bare-except          - `except:` with no class
+  silent-except        - `except X: pass` or `except X: ...` (single statement)
+  no-asyncio           - `import asyncio` / `from asyncio import ...`
+                         Opt out per import line: trailing `# noqa: ANYIO_OK`
+  no-pandas            - `import pandas` / `from pandas import ...`
+                         Opt out per import line: trailing `# noqa: PANDAS_OK`
+  mutable-dataclass    - @dataclass without frozen=True
+                         Opt out: trailing `# noqa: MUTABLE_OK`
+  missing-slots        - @dataclass without slots=True
+                         Opt out: trailing `# noqa: SLOTS_OK`
+  raw-dict-return      - function returns bare `dict` type
+                         Opt out: trailing `# noqa: DICT_OK`
+  missing-assert-never - match statement without assert_never in default case
+                         Opt out: `# noqa: MATCH_OK` on the match line
+  generic-exception    - raise ValueError/TypeError/RuntimeError with bare string
+                         Opt out: trailing `# noqa: GENERIC_ERR_OK`
+  no-object            - `object` used as type annotation (param, return, variable)
+                         Opt out: trailing `# noqa: OBJECT_OK`
+  if-elif-on-variant   - isinstance/enum-comparison if/elif chain (should be match/case)
+                         Opt out: trailing `# noqa: IF_VARIANT_OK`
+  oversized-module     - file exceeds 250 pure LOC (non-blank, non-comment)
+                         Opt out: `# noqa: SIZE_OK` in first 10 lines
+  broad-except         - `except Exception` / `except BaseException` (too broad)
+                         Opt out: trailing `# noqa: BROAD_EXCEPT_OK`
+
+Usage:
+  check-no-excuse-rules.py <file-or-dir>...
+
+Exit codes:
+  0 - no violations
+  1 - one or more violations
+  2 - input error (path missing, etc.)
+"""
+from __future__ import annotations
+
+import ast
+import io
+import re
+import sys
+import tokenize
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+EXCLUDED_DIRS = frozenset({
+    ".git", ".hg", ".svn", ".venv", "venv", "env", ".env",
+    "__pycache__", ".tox", ".nox", "dist", "build", ".eggs",
+    ".ruff_cache", ".mypy_cache", ".pytest_cache", ".basedpyright",
+    "node_modules",
+})
+
+SUPPRESSION_RE = re.compile(r"#\s*(type|pyright)\s*:\s*ignore\b")
+ANYIO_OK_RE = re.compile(r"#\s*noqa:\s*ANYIO_OK\b")
+PANDAS_OK_RE = re.compile(r"#\s*noqa:\s*PANDAS_OK\b")
+
+BANNED_IMPORTS: dict[str, tuple[str, re.Pattern[str], str]] = {
+    "asyncio": (
+        "no-asyncio",
+        ANYIO_OK_RE,
+        "import asyncio - use anyio (opt out: trailing `# noqa: ANYIO_OK`)",
+    ),
+    "pandas": (
+        "no-pandas",
+        PANDAS_OK_RE,
+        "import pandas - use polars (opt out: trailing `# noqa: PANDAS_OK`)",
+    ),
+}
+
+# Opt-out patterns for new Rust-like rules
+MUTABLE_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*MUTABLE_OK")
+SLOTS_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*SLOTS_OK")
+DICT_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*DICT_OK")
+MATCH_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*MATCH_OK")
+GENERIC_ERR_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*GENERIC_ERR_OK")
+OBJECT_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*OBJECT_OK")
+IF_VARIANT_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*IF_VARIANT_OK")
+SIZE_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*SIZE_OK")
+BROAD_EXCEPT_OK_RE: re.Pattern[str] = re.compile(r"#\s*noqa:\s*BROAD_EXCEPT_OK")
+
+PURE_LOC_LIMIT: int = 250
+
+
+@dataclass(frozen=True, slots=True)
+class Violation:
+    rule: str
+    file: Path
+    line: int
+    col: int
+    message: str
+
+    def render(self) -> str:
+        return f"{self.file}:{self.line}:{self.col}: [{self.rule}] {self.message}"
+
+
+def discover_files(inputs: Iterable[Path]) -> list[Path]:
+    seen: set[Path] = set()
+    for raw in inputs:
+        path = raw.resolve()
+        if not path.exists():
+            print(f"check-no-excuse-rules: input does not exist: {path}", file=sys.stderr)
+            sys.exit(2)
+        if path.is_file():
+            if path.suffix == ".py":
+                seen.add(path)
+            continue
+        for child in path.rglob("*.py"):
+            if any(part in EXCLUDED_DIRS for part in child.parts):
+                continue
+            seen.add(child)
+    return sorted(seen)
+
+
+def is_any_node(node: ast.AST) -> bool:
+    if isinstance(node, ast.Name):
+        return node.id == "Any"
+    if isinstance(node, ast.Attribute):
+        return node.attr == "Any"
+    return False
+
+
+def is_cast_callable(node: ast.AST) -> bool:
+    if isinstance(node, ast.Name):
+        return node.id == "cast"
+    if isinstance(node, ast.Attribute):
+        return node.attr == "cast"
+    return False
+
+
+def find_node_violations(tree: ast.AST, file: Path) -> list[Violation]:
+    violations: list[Violation] = []
+
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.Call)
+            and is_cast_callable(node.func)
+            and node.args
+            and is_any_node(node.args[0])
+        ):
+            violations.append(Violation(
+                rule="cast-any",
+                file=file,
+                line=node.lineno,
+                col=node.col_offset + 1,
+                message="cast(Any, ...) - narrow with isinstance/TypeGuard or use a Protocol/TypedDict",
+            ))
+
+        if isinstance(node, ast.ExceptHandler):
+            if node.type is None:
+                violations.append(Violation(
+                    rule="bare-except",
+                    file=file,
+                    line=node.lineno,
+                    col=node.col_offset + 1,
+                    message="bare `except:` - catch the narrowest exception you mean",
+                ))
+
+            if len(node.body) != 1:
+                continue
+
+            body = node.body[0]
+            if isinstance(body, ast.Pass):
+                violations.append(Violation(
+                    rule="silent-except",
+                    file=file,
+                    line=body.lineno,
+                    col=body.col_offset + 1,
+                    message="silent `except: pass` - log, re-raise, or actually handle the error",
+                ))
+            elif (
+                isinstance(body, ast.Expr)
+                and isinstance(body.value, ast.Constant)
+                and body.value.value is Ellipsis
+            ):
+                violations.append(Violation(
+                    rule="silent-except",
+                    file=file,
+                    line=body.lineno,
+                    col=body.col_offset + 1,
+                    message="silent `except: ...` - log, re-raise, or actually handle the error",
+                ))
+
+    return violations
+
+
+def find_import_violations(tree: ast.AST, source_lines: list[str], file: Path) -> list[Violation]:
+    violations: list[Violation] = []
+
+    def line_text(lineno: int) -> str:
+        index = lineno - 1
+        return source_lines[index] if 0 <= index < len(source_lines) else ""
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):  # noqa: IF_VARIANT_OK  — filtering walk, not closed union
+            for alias in node.names:
+                top = alias.name.split(".")[0]
+                if top not in BANNED_IMPORTS:
+                    continue
+                rule, opt_re, message = BANNED_IMPORTS[top]
+                if opt_re.search(line_text(node.lineno)):
+                    continue
+                violations.append(Violation(
+                    rule=rule,
+                    file=file,
+                    line=node.lineno,
+                    col=node.col_offset + 1,
+                    message=message,
+                ))
+        elif isinstance(node, ast.ImportFrom):
+            top = (node.module or "").split(".")[0]
+            if top not in BANNED_IMPORTS:
+                continue
+            rule, opt_re, message = BANNED_IMPORTS[top]
+            if opt_re.search(line_text(node.lineno)):
+                continue
+            violations.append(Violation(
+                rule=rule,
+                file=file,
+                line=node.lineno,
+                col=node.col_offset + 1,
+                message=message,
+            ))
+
+    return violations
+
+
+def find_comment_violations(source: str, file: Path) -> list[Violation]:
+    """Use tokenize so we don't false-match `# type: ignore` inside string literals."""
+    violations: list[Violation] = []
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except tokenize.TokenError as exc:
+        print(f"check-no-excuse-rules: tokenize failed for {file}: {exc}", file=sys.stderr)
+        return violations
+
+    for tok in tokens:
+        if tok.type != tokenize.COMMENT:
+            continue
+        match = SUPPRESSION_RE.search(tok.string)
+        if not match:
+            continue
+        kind = match.group(1)
+        rule = "type-ignore" if kind == "type" else "pyright-ignore"
+        violations.append(Violation(
+            rule=rule,
+            file=file,
+            line=tok.start[0],
+            col=tok.start[1] + match.start() + 1,
+            message=f"`# {kind}: ignore` - fix the underlying type instead",
+        ))
+    return violations
+
+
+# ─────────────────────────────────────────────────────────────────
+# Rust-like pattern checks
+# ─────────────────────────────────────────────────────────────────
+
+
+def _has_keyword(decorator_node: ast.Call, keyword: str) -> bool | None:
+    """Check if a decorator call has a specific keyword argument.
+
+    Returns True if keyword is True, False if keyword is False or absent, None if not a Call.
+    """
+    for kw in decorator_node.keywords:
+        if kw.arg == keyword and isinstance(kw.value, ast.Constant):
+            return bool(kw.value.value)
+    return False
+
+
+def _is_dataclass_decorator(node: ast.expr) -> tuple[bool, ast.Call | None]:
+    """Return (is_dataclass, call_node_or_None)."""
+    if isinstance(node, ast.Name) and node.id == "dataclass":
+        return True, None
+    if isinstance(node, ast.Attribute) and node.attr == "dataclass":
+        return True, None
+    if isinstance(node, ast.Call):
+        inner, _ = _is_dataclass_decorator(node.func)
+        if inner:
+            return True, node
+    return False, None
+
+
+def find_dataclass_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check @dataclass decorators for frozen=True and slots=True."""
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        for dec in node.decorator_list:
+            is_dc, call_node = _is_dataclass_decorator(dec)
+            if not is_dc:
+                continue
+
+            # Get the line of the decorator for opt-out check
+            dec_line = source_lines[dec.lineno - 1] if dec.lineno <= len(source_lines) else ""
+
+            if call_node is not None:
+                has_frozen = _has_keyword(call_node, "frozen")
+                has_slots = _has_keyword(call_node, "slots")
+            else:
+                # bare @dataclass with no arguments
+                has_frozen = False
+                has_slots = False
+
+            if not has_frozen and not MUTABLE_OK_RE.search(dec_line):
+                violations.append(Violation(
+                    rule="mutable-dataclass",
+                    file=file,
+                    line=dec.lineno,
+                    col=dec.col_offset + 1,
+                    message=f"class {node.name}: @dataclass without frozen=True",
+                ))
+
+            if not has_slots and not SLOTS_OK_RE.search(dec_line):
+                violations.append(Violation(
+                    rule="missing-slots",
+                    file=file,
+                    line=dec.lineno,
+                    col=dec.col_offset + 1,
+                    message=f"class {node.name}: @dataclass without slots=True",
+                ))
+    return violations
+
+
+def find_dict_return_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check for functions returning bare `dict` type."""
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        ret = node.returns
+        if ret is None:
+            continue
+        # Check for bare `dict` return annotation
+        is_bare_dict = (
+            (isinstance(ret, ast.Name) and ret.id == "dict")
+            or (isinstance(ret, ast.Attribute) and ret.attr == "dict")
+        )
+        if not is_bare_dict:
+            continue
+
+        func_line = source_lines[node.lineno - 1] if node.lineno <= len(source_lines) else ""
+        if DICT_OK_RE.search(func_line):
+            continue
+
+        violations.append(Violation(
+            rule="raw-dict-return",
+            file=file,
+            line=node.lineno,
+            col=node.col_offset + 1,
+            message=f"`{node.name}` returns bare dict - use TypedDict/dataclass/Pydantic model",
+        ))
+    return violations
+
+
+def find_match_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check match statements for assert_never in default case."""
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Match):
+            continue
+
+        match_line = source_lines[node.lineno - 1] if node.lineno <= len(source_lines) else ""
+        if MATCH_OK_RE.search(match_line):
+            continue
+
+        has_assert_never = False
+        for case in node.cases:
+            # Wildcard: `case _:` -> MatchAs(pattern=None, name=None)
+            #           `case _ as x:` -> MatchAs(pattern=MatchAs(pattern=None, name=None), name="x")
+            pattern = case.pattern
+            is_wildcard = (
+                isinstance(pattern, ast.MatchAs)
+                and (
+                    pattern.pattern is None
+                    or (
+                        isinstance(pattern.pattern, ast.MatchAs)
+                        and pattern.pattern.pattern is None
+                        and pattern.pattern.name is None
+                    )
+                )
+            )
+            if not is_wildcard:
+                continue
+            # Check if body contains assert_never call
+            for stmt in case.body:
+                if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+                    func = stmt.value.func
+                    if (
+                        (isinstance(func, ast.Name) and func.id == "assert_never")
+                        or (isinstance(func, ast.Attribute) and func.attr == "assert_never")
+                    ):
+                        has_assert_never = True
+                        break
+
+        if not has_assert_never:
+            violations.append(Violation(
+                rule="missing-assert-never",
+                file=file,
+                line=node.lineno,
+                col=node.col_offset + 1,
+                message="match without `case _: assert_never(x)` default",
+            ))
+    return violations
+
+
+def find_generic_exception_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check for raise ValueError/TypeError/RuntimeError with bare string or f-string."""
+    GENERIC_EXCEPTIONS = {"ValueError", "TypeError", "RuntimeError", "KeyError"}
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Raise) or node.exc is None:
+            continue
+        exc = node.exc
+        # Match: raise SomeError("string literal")
+        if not isinstance(exc, ast.Call):
+            continue
+        func = exc.func
+        exc_name: str | None = None
+        if isinstance(func, ast.Name) and func.id in GENERIC_EXCEPTIONS:
+            exc_name = func.id
+        elif isinstance(func, ast.Attribute) and func.attr in GENERIC_EXCEPTIONS:
+            exc_name = func.attr
+        if exc_name is None:
+            continue
+        # Check if all arguments are string literals or f-strings
+        if not exc.args:
+            continue
+        all_str = all(
+            (isinstance(arg, ast.Constant) and isinstance(arg.value, str))
+            or isinstance(arg, ast.JoinedStr)
+            for arg in exc.args
+        )
+        if not all_str:
+            continue
+
+        raise_line = source_lines[node.lineno - 1] if node.lineno <= len(source_lines) else ""
+        if GENERIC_ERR_OK_RE.search(raise_line):
+            continue
+
+        violations.append(Violation(
+            rule="generic-exception",
+            file=file,
+            line=node.lineno,
+            col=node.col_offset + 1,
+            message=f"`raise {exc_name}(\"...\")` - define a typed error class instead",
+        ))
+    return violations
+
+
+def _is_isinstance_test(node: ast.expr) -> bool:
+    """Check if node is an isinstance() call."""
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "isinstance"
+    )
+
+
+def _is_enum_comparison(node: ast.expr) -> bool:
+    """Check if node is `x == Enum.VALUE` or `x is Enum.VALUE`."""
+    if isinstance(node, ast.Compare) and len(node.ops) == 1:
+        op = node.ops[0]
+        if isinstance(op, (ast.Eq, ast.Is)):
+            comparator = node.comparators[0]
+            # x == Enum.VALUE  (attribute access on the right)
+            if isinstance(comparator, ast.Attribute):
+                return True
+            # Enum.VALUE == x  (attribute access on the left)
+            if isinstance(node.left, ast.Attribute):
+                return True
+    return False
+
+
+def find_object_annotation_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check for `object` used as a type annotation."""
+    violations: list[Violation] = []
+
+    def _check_annotation(ann: ast.expr | None) -> None:
+        if ann is None:
+            return
+        for child in ast.walk(ann):
+            if isinstance(child, ast.Name) and child.id == "object":
+                line = source_lines[child.lineno - 1] if child.lineno <= len(source_lines) else ""
+                if OBJECT_OK_RE.search(line):
+                    return
+                violations.append(Violation(
+                    rule="no-object",
+                    file=file,
+                    line=child.lineno,
+                    col=child.col_offset + 1,
+                    message="`object` as type annotation \u2014 use Protocol, TypeVar, or union",
+                ))
+
+    for node in ast.walk(tree):
+        match node:  # noqa: MATCH_OK  — filtering walk, not discriminating a closed union
+            case ast.FunctionDef() | ast.AsyncFunctionDef():
+                all_args = (
+                    node.args.args
+                    + node.args.posonlyargs
+                    + node.args.kwonlyargs
+                )
+                for arg in all_args:
+                    _check_annotation(arg.annotation)
+                if node.args.vararg:
+                    _check_annotation(node.args.vararg.annotation)
+                if node.args.kwarg:
+                    _check_annotation(node.args.kwarg.annotation)
+                _check_annotation(node.returns)
+            case ast.AnnAssign():
+                _check_annotation(node.annotation)
+    return violations
+
+
+def find_if_elif_variant_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check for if/elif chains on isinstance or enum comparison."""
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.If):
+            continue
+
+        line = source_lines[node.lineno - 1] if node.lineno <= len(source_lines) else ""
+        if IF_VARIANT_OK_RE.search(line):
+            continue
+
+        is_variant_test = _is_isinstance_test(node.test) or _is_enum_comparison(node.test)
+        if not is_variant_test:
+            continue
+
+        # Must have at least one elif that is also a variant test
+        orelse = node.orelse
+        while orelse and len(orelse) == 1 and isinstance(orelse[0], ast.If):
+            elif_node = orelse[0]
+            if _is_isinstance_test(elif_node.test) or _is_enum_comparison(elif_node.test):
+                violations.append(Violation(
+                    rule="if-elif-on-variant",
+                    file=file,
+                    line=node.lineno,
+                    col=node.col_offset + 1,
+                    message="isinstance/enum if/elif chain \u2014 use match/case + assert_never",
+                ))
+                break
+            orelse = elif_node.orelse
+    return violations
+
+
+def find_broad_except_violations(
+    tree: ast.Module, source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check for except Exception / except BaseException (too broad)."""
+    BROAD_EXCEPTIONS = {"Exception", "BaseException"}
+    violations: list[Violation] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ExceptHandler):
+            continue
+        if node.type is None:
+            continue  # already caught by bare-except
+
+        exc_name: str | None = None
+        if isinstance(node.type, ast.Name) and node.type.id in BROAD_EXCEPTIONS:
+            exc_name = node.type.id
+        elif isinstance(node.type, ast.Attribute) and node.type.attr in BROAD_EXCEPTIONS:
+            exc_name = node.type.attr
+        if exc_name is None:
+            continue
+
+        line = source_lines[node.lineno - 1] if node.lineno <= len(source_lines) else ""
+        if BROAD_EXCEPT_OK_RE.search(line):
+            continue
+
+        violations.append(Violation(
+            rule="broad-except",
+            file=file,
+            line=node.lineno,
+            col=node.col_offset + 1,
+            message=f"`except {exc_name}` is too broad \u2014 catch the specific exception you expect",
+        ))
+    return violations
+
+
+def find_oversized_module_violations(
+    source_lines: list[str], file: Path,
+) -> list[Violation]:
+    """Check if file exceeds 250 pure LOC (non-blank, non-comment)."""
+    # File-level opt-out in first 10 lines (shebang + script metadata can push it down)
+    for line in source_lines[:10]:
+        if SIZE_OK_RE.search(line):
+            return []
+
+    pure_loc = sum(
+        1 for line in source_lines
+        if line.strip() and not line.strip().startswith("#")
+    )
+    if pure_loc > PURE_LOC_LIMIT:
+        return [Violation(
+            rule="oversized-module",
+            file=file,
+            line=1,
+            col=1,
+            message=f"{pure_loc} pure LOC (limit: {PURE_LOC_LIMIT}) \u2014 split by responsibility",
+        )]
+    return []
+
+
+def check_file(file: Path) -> list[Violation]:
+    source = file.read_text(encoding="utf-8")
+    try:
+        tree = ast.parse(source, filename=str(file))
+    except SyntaxError as exc:
+        return [Violation(
+            rule="syntax-error",
+            file=file,
+            line=exc.lineno or 1,
+            col=exc.offset or 1,
+            message=f"SyntaxError: {exc.msg}",
+        )]
+
+    source_lines = source.splitlines()
+    return [
+        *find_node_violations(tree, file),
+        *find_import_violations(tree, source_lines, file),
+        *find_comment_violations(source, file),
+        *find_dataclass_violations(tree, source_lines, file),
+        *find_dict_return_violations(tree, source_lines, file),
+        *find_match_violations(tree, source_lines, file),
+        *find_generic_exception_violations(tree, source_lines, file),
+        *find_object_annotation_violations(tree, source_lines, file),
+        *find_if_elif_variant_violations(tree, source_lines, file),
+        *find_oversized_module_violations(source_lines, file),
+        *find_broad_except_violations(tree, source_lines, file),
+    ]
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("usage: check-no-excuse-rules.py <file-or-dir>...", file=sys.stderr)
+        return 2
+
+    files = discover_files(Path(arg) for arg in sys.argv[1:])
+    if not files:
+        print("check-no-excuse-rules: no .py files found", file=sys.stderr)
+        return 0
+
+    violations: list[Violation] = []
+    for file in files:
+        violations.extend(check_file(file))
+
+    if not violations:
+        print(f"no violations in {len(files)} file(s)")
+        return 0
+
+    for violation in violations:
+        print(violation.render(), file=sys.stderr)
+    print(
+        f"\n{len(violations)} violation(s) in {len(files)} file(s)",
+        file=sys.stderr,
+    )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())