sloplintpy 0.2.0

Fast, deterministic linter for AI 'slop' in Python — runs right after Ruff.

sloplint

A fast, deterministic, no-LLM linter that counters AI slop in Python — a deliberately nitpicking, opinionated layer that runs right after Ruff in the same CI job. Ruff handles standard linting; sloplint adds the strict, slop-specific judgments Ruff intentionally won't ship, and never re-checks anything Ruff already covers.

Written in Rust, reusing Ruff's own parser crates for a full-fidelity AST + token stream.

What it targets

Patterns that no mainstream linter flags today:

• Redundant "what" comments & docstrings that just restate the code (default: comments are banned, configurable per-path).
• Cross-file duplicated / near-duplicate functions — copy-paste and "same logic, slightly different" (the flagship clone engine).
• Redundant type hints, overly defensive try/except, verbose mechanical naming.
• ASCII-only enforcement (no emoji), deep-nesting caps, oversized files, flat-directory fanout.
• Deeply nested data-structure literals — a dict-of-lists-of-dicts inline blob past a configurable depth, distinct from control-flow nesting (model it with a named type).
• Software-quality-metric badges + a per-PR summary, via a GitHub Action.

Installation

sloplint ships on PyPI as sloplintpy (the wheel bundles the native binary — no Rust toolchain needed). The installed command is sloplint.

Run it directly with uvx (the package and command differ, so use --from):

uvx --from sloplintpy sloplint check    # Lint all files in the current directory.
uvx --from sloplintpy sloplint metrics  # Report software-quality metrics.

Or install sloplintpy with uv (recommended), pip, or pipx — then run sloplint:

# With uv.
uv tool install sloplintpy@latest   # Install the `sloplint` command globally.
uv add --dev sloplintpy             # Or add it to your project.

# With pip.
pip install sloplintpy

# With pipx.
pipx install sloplintpy

Usage

Once installed, sloplint is a native binary on your PATH:

sloplint check path/to/code              # lint (exit 1 on findings)
sloplint check src --format sarif        # SARIF / json / github / text
sloplint metrics src                     # software-quality metrics table
sloplint metrics src --format github     # PR-summary markdown (CC risk tiers)
sloplint metrics src --max-cyclomatic 10 # CI gate: exit 1 over McCabe's ceiling
sloplint metrics src --badges badges/    # emit SVG + shields-endpoint badges
sloplint parse file.py                   # dump AST + tokens (debug aid)

From a clone, run it through cargo instead (cargo run -p sloplint -- check path/to/code), or build a wheel locally with maturin (maturin build --release).

Comments are banned by default; relax per-path in sloplint.toml. Heuristic rules (SLP001/002/040/060/084/120) are preview — enable with --preview. SLP120 flags low-cohesion "god classes" via LCOM4 (methods that split into unrelated groups; thresholds lcom4_max_components / lcom4_min_methods under [limits]).

GitHub Action

Run sloplint on every PR — it uploads SARIF (inline annotations), posts a findings summary comment, and can emit metric badges:

permissions:
  contents: read
  security-events: write
  pull-requests: write
jobs:
  sloplint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: galthran-wq/sloplint@main
        with:
          paths: src
          badges-dir: .sloplint-badges   # optional

Intended to run after Ruff in the same job. See action.yml for all inputs.

Required permissions: security-events: write (SARIF upload) and pull-requests: write (PR comment) — both shown above. Without them the action degrades gracefully (it warns rather than failing).

By default the action downloads a prebuilt binary for the runner (set version: to a release tag like v0.1.0, or latest); if none is available it builds from source. Cut a release to publish binaries:

git tag v0.1.0 && git push origin v0.1.0   # triggers .github/workflows/release.yml

Layout

Crate	Role
sloplint	CLI binary
sloplint_linter	all rules + core run logic (cf. ruff_linter)
sloplint_python	parser seam over the pinned ruff_* crates
sloplint_diagnostics	rule-independent diagnostic model
sloplint_clone	near-duplicate function detection
sloplint_metrics	quality metrics + badges
sloplint_report	output formatters (text/JSON/SARIF/markdown)
sloplint_dev	development utilities (cf. ruff_dev)