Add operational transform example

2022-11-08 19:09:55 -05:00
9578 changed files with 42986 additions and 1166770 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,14 +1,2 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
-benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
-
-# statically link the C runtime so the executable does not depend on
-# that shared/dynamic library.
-#
-# See: https://github.com/astral-sh/ruff/issues/11503
-[target.'cfg(all(target_env="msvc", target_os = "windows"))']
-rustflags = ["-C", "target-feature=+crt-static"]
-
-[target.'wasm32-unknown-unknown']
-# See https://docs.rs/getrandom/latest/getrandom/#webassembly-support
-rustflags = ["--cfg", 'getrandom_backend="wasm_js"']
--- a/.config/nextest.toml
+++ b/.config/nextest.toml
@@ -1,15 +0,0 @@
-[profile.ci]
-# Print out output for failing tests as soon as they fail, and also at the end
-# of the run (for easy scrollability).
-failure-output = "immediate-final"
-# Do not cancel the test run on the first failure.
-fail-fast = false
-
-status-level = "skip"
-
-# Mark tests that take longer than 1s as slow.
-# Terminate after 60s as a stop-gap measure to terminate on deadlock.
-slow-timeout =  { period = "1s", terminate-after = 60 }
-
-# Show slow jobs in the final summary
-final-status-level = "slow"
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,46 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/rust
-{
-	"name": "Ruff",
-	"image": "mcr.microsoft.com/devcontainers/rust:0-1-bullseye",
-	"mounts": [
-		{
-			"source": "devcontainer-cargo-cache-${devcontainerId}",
-			"target": "/usr/local/cargo",
-			"type": "volume"
-		}
-	],
-	"customizations": {
-		"codespaces": {
-			"openFiles": [
-				"CONTRIBUTING.md"
-			]
-		},
-		"vscode": {
-			"extensions": [
-				"ms-python.python",
-				"rust-lang.rust-analyzer",
-				"fill-labs.dependi",
-				"tamasfe.even-better-toml",
-				"Swellaby.vscode-rust-test-adapter",
-				"charliermarsh.ruff"
-			],
-			"settings": {
-				"rust-analyzer.updates.askBeforeDownload": false
-			}
-		}
-	},
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	"features": {
-		"ghcr.io/devcontainers/features/python": {
-			"installTools": false
-		}
-	},
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-	"postCreateCommand": ".devcontainer/post-create.sh"
-	// Configure tool-specific properties.
-	// "customizations": {},
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}
--- a/.devcontainer/post-create.sh
+++ b/.devcontainer/post-create.sh
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-rustup default < rust-toolchain
-rustup component add clippy rustfmt
-cargo install cargo-insta
-cargo fetch
-
-pip install maturin pre-commit
--- a/.editorconfig
+++ b/.editorconfig
@@ -10,14 +10,5 @@ indent_style = space
 insert_final_newline = true
 indent_size = 2

-[*.{rs,py,pyi}]
+[*.{rs,py}]
 indent_size = 4
-
-[*.snap]
-trim_trailing_whitespace = false
-
-[*.md]
-max_line_length = 100
-
-[*.toml]
-indent_size = 4
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,27 +0,0 @@
-* text=auto eol=lf
-
-crates/ruff_linter/resources/test/fixtures/isort/line_ending_crlf.py text eol=crlf
-crates/ruff_linter/resources/test/fixtures/pycodestyle/W605_1.py text eol=crlf
-crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_2.py text eol=crlf
-crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_3.py text eol=crlf
-
-crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_crlf.py text eol=crlf
-crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_crlf.py.snap text eol=crlf
-
-crates/ruff_python_parser/resources/invalid/re_lexing/line_continuation_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text eol=cr
-
-crates/ruff_linter/resources/test/fixtures/ruff/RUF046_CR.py text eol=cr
-crates/ruff_linter/resources/test/fixtures/ruff/RUF046_LF.py text eol=lf
-
-crates/ruff_linter/resources/test/fixtures/pyupgrade/UP018_CR.py text eol=cr
-crates/ruff_linter/resources/test/fixtures/pyupgrade/UP018_LF.py text eol=lf
-
-crates/ruff_python_parser/resources/inline linguist-generated=true
-
-ruff.schema.json -diff linguist-generated=true text=auto eol=lf
-ty.schema.json -diff linguist-generated=true text=auto eol=lf
-crates/ruff_python_ast/src/generated.rs -diff linguist-generated=true text=auto eol=lf
-crates/ruff_python_formatter/src/generated.rs -diff linguist-generated=true text=auto eol=lf
-*.md.snap linguist-language=Markdown
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,24 +0,0 @@
-# GitHub code owners file. For more info: https://help.github.com/articles/about-codeowners/
-#
-# - Comment lines begin with `#` character.
-# - Each line is a file pattern followed by one or more owners.
-# - The '*' pattern is global owners.
-# - Order is important. The last matching pattern has the most precedence.
-
-/crates/ruff_notebook/ @dhruvmanila
-/crates/ruff_formatter/ @MichaReiser
-/crates/ruff_python_formatter/ @MichaReiser
-/crates/ruff_python_parser/ @MichaReiser @dhruvmanila
-/crates/ruff_annotate_snippets/ @BurntSushi
-
-# flake8-pyi
-/crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood
-
-# Script for fuzzing the parser/ty etc.
-/python/py-fuzzer/ @AlexWaygood
-
-# ty
-/crates/ty* @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/scripts/ty_benchmark/ @carljm @MichaReiser @AlexWaygood @sharkdp @dcreager
-/crates/ty_python_semantic @carljm @AlexWaygood @sharkdp @dcreager
--- a/.github/ISSUE_TEMPLATE/1_bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/1_bug_report.yaml
@@ -1,31 +0,0 @@
-name: Bug report
-description: Report an error or unexpected behavior
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to report an issue! We're glad to have you involved with Ruff.
-
-        **Before reporting, please make sure to search through [existing issues](https://github.com/astral-sh/ruff/issues?q=is:issue+is:open+label:bug) (including [closed](https://github.com/astral-sh/ruff/issues?q=is:issue%20state:closed%20label:bug)).**
-
-  - type: textarea
-    attributes:
-      label: Summary
-      description: |
-        A clear and concise description of the bug, including a minimal reproducible example.
-
-        Be sure to include the command you invoked (e.g., `ruff check /path/to/file.py --fix`), ideally including the `--isolated` flag and
-        the current Ruff settings (e.g., relevant sections from your `pyproject.toml`).
-
-        If possible, try to include the [playground](https://play.ruff.rs) link that reproduces this issue.
-
-    validations:
-      required: true
-
-  - type: input
-    attributes:
-      label: Version
-      description: What version of ruff are you using? (see `ruff version`)
-      placeholder: e.g., ruff 0.9.3 (90589372d 2025-01-23)
-    validations:
-      required: false
--- a/.github/ISSUE_TEMPLATE/2_rule_request.yaml
+++ b/.github/ISSUE_TEMPLATE/2_rule_request.yaml
@@ -1,10 +0,0 @@
-name: Rule request
-description: Anything related to lint rules (proposing new rules, changes to existing rules, auto-fixes, etc.)
-body:
-  - type: textarea
-    attributes:
-      label: Summary
-      description: |
-        A clear and concise description of the relevant request. If applicable, please describe the current behavior as well.
-    validations:
-      required: true
--- a/.github/ISSUE_TEMPLATE/3_question.yaml
+++ b/.github/ISSUE_TEMPLATE/3_question.yaml
@@ -1,18 +0,0 @@
-name: Question
-description: Ask a question about Ruff
-labels: ["question"]
-body:
-  - type: textarea
-    attributes:
-      label: Question
-      description: Describe your question in detail.
-    validations:
-      required: true
-
-  - type: input
-    attributes:
-      label: Version
-      description: What version of ruff are you using? (see `ruff version`)
-      placeholder: e.g., ruff 0.9.3 (90589372d 2025-01-23)
-    validations:
-      required: false
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,11 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Report an issue with ty
-    url: https://github.com/astral-sh/ty/issues/new/choose
-    about: Please report issues for our type checker ty in the ty repository.
-  - name: Documentation
-    url: https://docs.astral.sh/ruff
-    about: Please consult the documentation before creating an issue.
-  - name: Community
-    url: https://discord.com/invite/astral-sh
-    about: Join our Discord community to ask questions and collaborate.
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,16 +0,0 @@
-<!--
-Thank you for contributing to Ruff/ty! To help us out with reviewing, please consider the following:
-
- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title? (Please prefix with `[ty]` for ty pull
-  requests.)
- Does this pull request include references to any relevant issues?
-->
-
-## Summary
-
-<!-- What's the purpose of the change? What does it do, and why? -->
-
-## Test Plan
-
-<!-- How was it tested? -->
--- a/.github/actionlint.yaml
+++ b/.github/actionlint.yaml
@@ -1,11 +0,0 @@
-# Configuration for the actionlint tool, which we run via pre-commit
-# to verify the correctness of the syntax in our GitHub Actions workflows.
-
-self-hosted-runner:
-  # Various runners we use that aren't recognized out-of-the-box by actionlint:
-  labels:
-    - depot-ubuntu-latest-8
-    - depot-ubuntu-22.04-16
-    - depot-ubuntu-22.04-32
-    - github-windows-2025-x86_64-8
-    - github-windows-2025-x86_64-16
--- a/.github/mypy-primer-ty.toml
+++ b/.github/mypy-primer-ty.toml
@@ -1,8 +0,0 @@
-#:schema ../ty.schema.json
-# Configuration overrides for the mypy primer run
-
-# Enable off-by-default rules.
-[rules]
-possibly-unresolved-reference = "warn"
-unused-ignore-comment = "warn"
-division-by-zero = "warn"
--- a/.github/renovate.json5
+++ b/.github/renovate.json5
@@ -1,115 +0,0 @@
-{
-  $schema: "https://docs.renovatebot.com/renovate-schema.json",
-  dependencyDashboard: true,
-  suppressNotifications: ["prEditedNotification"],
-  extends: ["config:recommended"],
-  labels: ["internal"],
-  schedule: ["before 4am on Monday"],
-  semanticCommits: "disabled",
-  separateMajorMinor: false,
-  prHourlyLimit: 10,
-  enabledManagers: ["github-actions", "pre-commit", "cargo", "pep621", "pip_requirements", "npm"],
-  cargo: {
-    // See https://docs.renovatebot.com/configuration-options/#rangestrategy
-    rangeStrategy: "update-lockfile",
-  },
-  pep621: {
-    // The default for this package manager is to only search for `pyproject.toml` files
-    // found at the repository root: https://docs.renovatebot.com/modules/manager/pep621/#file-matching
-    fileMatch: ["^(python|scripts)/.*pyproject\\.toml$"],
-  },
-  pip_requirements: {
-    // The default for this package manager is to run on all requirements.txt files:
-    // https://docs.renovatebot.com/modules/manager/pip_requirements/#file-matching
-    // `fileMatch` doesn't work for excluding files; to exclude `requirements.txt` files
-    // outside the `doc/` directory, we instead have to use `ignorePaths`. Unlike `fileMatch`,
-    // which takes a regex string, `ignorePaths` takes a glob string, so we have to use
-    // a "negative glob pattern".
-    // See:
-    // - https://docs.renovatebot.com/modules/manager/#ignoring-files-that-match-the-default-filematch
-    // - https://docs.renovatebot.com/configuration-options/#ignorepaths
-    // - https://docs.renovatebot.com/string-pattern-matching/#negative-matching
-    ignorePaths: ["!docs/requirements*.txt"]
-  },
-  npm: {
-    // The default for this package manager is to only search for `package.json` files
-    // found at the repository root: https://docs.renovatebot.com/modules/manager/npm/#file-matching
-    fileMatch: ["^playground/.*package\\.json$"],
-  },
-  "pre-commit": {
-    enabled: true,
-  },
-  packageRules: [
-    // Pin GitHub Actions to immutable SHAs.
-    {
-      matchDepTypes: ["action"],
-      pinDigests: true,
-    },
-    // Annotate GitHub Actions SHAs with a SemVer version.
-    {
-      extends: ["helpers:pinGitHubActionDigests"],
-      extractVersion: "^(?<version>v?\\d+\\.\\d+\\.\\d+)$",
-      versioning: "regex:^v?(?<major>\\d+)(\\.(?<minor>\\d+)\\.(?<patch>\\d+))?$",
-    },
-    {
-      // Group upload/download artifact updates, the versions are dependent
-      groupName: "Artifact GitHub Actions dependencies",
-      matchManagers: ["github-actions"],
-      matchDatasources: ["gitea-tags", "github-tags"],
-      matchPackageNames: ["actions/.*-artifact"],
-      description: "Weekly update of artifact-related GitHub Actions dependencies",
-    },
-    {
-      // This package rule disables updates for GitHub runners:
-      // we'd only pin them to a specific version
-      // if there was a deliberate reason to do so
-      groupName: "GitHub runners",
-      matchManagers: ["github-actions"],
-      matchDatasources: ["github-runners"],
-      description: "Disable PRs updating GitHub runners (e.g. 'runs-on: macos-14')",
-      enabled: false,
-    },
-    {
-      // Disable updates of `zip-rs`; intentionally pinned for now due to ownership change
-      // See: https://github.com/astral-sh/uv/issues/3642
-      matchPackageNames: ["zip"],
-      matchManagers: ["cargo"],
-      enabled: false,
-    },
-    {
-      // `mkdocs-material` requires a manual update to keep the version in sync
-      // with `mkdocs-material-insider`.
-      // See: https://squidfunk.github.io/mkdocs-material/insiders/upgrade/
-      matchManagers: ["pip_requirements"],
-      matchPackageNames: ["mkdocs-material"],
-      enabled: false,
-    },
-    {
-      groupName: "pre-commit dependencies",
-      matchManagers: ["pre-commit"],
-      description: "Weekly update of pre-commit dependencies",
-    },
-    {
-      groupName: "NPM Development dependencies",
-      matchManagers: ["npm"],
-      matchDepTypes: ["devDependencies"],
-      description: "Weekly update of NPM development dependencies",
-    },
-    {
-      groupName: "Monaco",
-      matchManagers: ["npm"],
-      matchPackageNames: ["monaco"],
-      description: "Weekly update of the Monaco editor",
-    },
-    {
-      groupName: "strum",
-      matchManagers: ["cargo"],
-      matchPackageNames: ["strum"],
-      description: "Weekly update of strum dependencies",
-    }
-  ],
-  vulnerabilityAlerts: {
-    commitMessageSuffix: "",
-    labels: ["internal", "security"],
-  },
-}
--- a/.github/workflows/build-binaries.yml
+++ b/.github/workflows/build-binaries.yml
@@ -1,480 +0,0 @@
-# Build ruff on all platforms.
-#
-# Generates both wheels (for PyPI) and archived binaries (for GitHub releases).
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
-# artifacts job within `cargo-dist`.
-name: "Build binaries"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-  pull_request:
-    paths:
-      # When we change pyproject.toml, we want to ensure that the maturin builds still work.
-      - pyproject.toml
-      # And when we change this workflow itself...
-      - .github/workflows/build-binaries.yml
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions: {}
-
-env:
-  PACKAGE_NAME: ruff
-  MODULE_NAME: ruff
-  PYTHON_VERSION: "3.13"
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  sdist:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build sdist"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          command: sdist
-          args: --out dist
-      - name: "Test sdist"
-        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
-      - name: "Upload sdist"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-sdist
-          path: dist
-
-  macos-x86_64:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: macos-14
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - x86_64"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: x86_64
-          args: --release --locked --out dist
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-macos-x86_64
-          path: dist
-      - name: "Archive binary"
-        run: |
-          TARGET=x86_64-apple-darwin
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-macos-x86_64
-          path: |
-            *.tar.gz
-            *.sha256
-
-  macos-aarch64:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: macos-14
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: arm64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - aarch64"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: aarch64
-          args: --release --locked --out dist
-      - name: "Test wheel - aarch64"
-        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
-          ruff --help
-          python -m ruff --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-aarch64-apple-darwin
-          path: dist
-      - name: "Archive binary"
-        run: |
-          TARGET=aarch64-apple-darwin
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-aarch64-apple-darwin
-          path: |
-            *.tar.gz
-            *.sha256
-
-  windows:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        platform:
-          - target: x86_64-pc-windows-msvc
-            arch: x64
-          - target: i686-pc-windows-msvc
-            arch: x86
-          - target: aarch64-pc-windows-msvc
-            arch: x64
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: ${{ matrix.platform.arch }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --locked --out dist
-        env:
-          # aarch64 build fails, see https://github.com/PyO3/maturin/issues/2110
-          XWIN_VERSION: 16
-      - name: "Test wheel"
-        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
-        shell: bash
-        run: |
-          python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.zip
-          7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
-          sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.zip
-            *.sha256
-
-  linux:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-gnu
-          - i686-unknown-linux-gnu
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: auto
-          args: --release --locked --out dist
-      - name: "Test wheel"
-        if: ${{ startsWith(matrix.target, 'x86_64') }}
-        run: |
-          pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
-          "${MODULE_NAME}" --help
-          python -m "${MODULE_NAME}" --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-${{ matrix.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-${{ matrix.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  linux-cross:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        platform:
-          - target: aarch64-unknown-linux-gnu
-            arch: aarch64
-            # see https://github.com/astral-sh/ruff/issues/3791
-            # and https://github.com/gnzlbg/jemallocator/issues/170#issuecomment-1503228963
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: armv7-unknown-linux-gnueabihf
-            arch: armv7
-          - target: s390x-unknown-linux-gnu
-            arch: s390x
-          - target: powerpc64le-unknown-linux-gnu
-            arch: ppc64le
-            # see https://github.com/astral-sh/ruff/issues/10073
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: powerpc64-unknown-linux-gnu
-            arch: ppc64
-            # see https://github.com/astral-sh/ruff/issues/10073
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: arm-unknown-linux-musleabihf
-            arch: arm
-
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: ${{ matrix.platform.target }}
-          manylinux: auto
-          docker-options: ${{ matrix.platform.maturin_docker_options }}
-          args: --release --locked --out dist
-      - uses: uraimo/run-on-arch-action@d94c13912ea685de38fccc1109385b83fd79427d # v3.0.1
-        if: ${{ matrix.platform.arch != 'ppc64' && matrix.platform.arch != 'ppc64le'}}
-        name: Test wheel
-        with:
-          arch: ${{ matrix.platform.arch == 'arm' && 'armv6' || matrix.platform.arch }}
-          distro: ${{ matrix.platform.arch == 'arm' && 'bullseye' || 'ubuntu20.04' }}
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update
-            apt-get install -y --no-install-recommends python3 python3-pip
-            pip3 install -U pip
-          run: |
-            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            ruff --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.platform.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  musllinux:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-musl
-          - i686-unknown-linux-musl
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: musllinux_1_2
-          args: --release --locked --out dist
-      - name: "Test wheel"
-        if: matrix.target == 'x86_64-unknown-linux-musl'
-        uses: addnab/docker-run-action@4f65fabd2431ebc8d299f8e5a018d79a769ae185 # v3
-        with:
-          image: alpine:latest
-          options: -v ${{ github.workspace }}:/io -w /io
-          run: |
-            apk add python3
-            python -m venv .venv
-            .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-${{ matrix.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-${{ matrix.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  musllinux-cross:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        platform:
-          - target: aarch64-unknown-linux-musl
-            arch: aarch64
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: armv7-unknown-linux-musleabihf
-            arch: armv7
-
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@aef21716ff3dcae8a1c301d23ec3e4446972a6e3 # v1.49.1
-        with:
-          target: ${{ matrix.platform.target }}
-          manylinux: musllinux_1_2
-          args: --release --locked --out dist
-          docker-options: ${{ matrix.platform.maturin_docker_options }}
-      - uses: uraimo/run-on-arch-action@d94c13912ea685de38fccc1109385b83fd79427d # v3.0.1
-        name: Test wheel
-        with:
-          arch: ${{ matrix.platform.arch }}
-          distro: alpine_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apk add python3
-          run: |
-            python -m venv .venv
-            .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.platform.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.tar.gz
-            *.sha256
--- a/.github/workflows/build-docker.yml
+++ b/.github/workflows/build-docker.yml
@@ -1,299 +0,0 @@
-# Build and publish a Docker image.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
-# artifacts job within `cargo-dist`.
-#
-# TODO(charlie): Ideally, the publish step would happen as a publish job within `cargo-dist`, but
-# sharing the built image as an artifact between jobs is challenging.
-name: "[ruff] Build Docker image"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-  pull_request:
-    paths:
-      - .github/workflows/build-docker.yml
-
-env:
-  RUFF_BASE_IMG: ghcr.io/${{ github.repository_owner }}/ruff
-
-jobs:
-  docker-build:
-    name: Build Docker image (ghcr.io/astral-sh/ruff) for ${{ matrix.platform }}
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - linux/amd64
-          - linux/arm64
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          submodules: recursive
-          persist-credentials: false
-
-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
-
-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Check tag consistency
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        env:
-          TAG: ${{ inputs.plan != '' && fromJson(inputs.plan).announcement_tag || 'dry-run' }}
-        run: |
-          version=$(grep -m 1 "^version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
-          if [ "${TAG}" != "${version}" ]; then
-            echo "The input tag does not match the version from pyproject.toml:" >&2
-            echo "${TAG}" >&2
-            echo "${version}" >&2
-            exit 1
-          else
-            echo "Releasing ${version}"
-          fi
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Defining this makes sure the org.opencontainers.image.version OCI label becomes the actual release version and not the branch name
-          tags: |
-            type=raw,value=dry-run,enable=${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-            type=pep440,pattern={{ version }},value=${{ inputs.plan != '' && fromJson(inputs.plan).announcement_tag || 'dry-run' }},enable=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Normalize Platform Pair (replace / with -)
-        run: |
-          platform=${{ matrix.platform }}
-          echo "PLATFORM_TUPLE=${platform//\//-}" >> "$GITHUB_ENV"
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Build and push by digest
-        id: build
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        with:
-          context: .
-          platforms: ${{ matrix.platform }}
-          cache-from: type=gha,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          cache-to: type=gha,mode=min,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          labels: ${{ steps.meta.outputs.labels }}
-          outputs: type=image,name=${{ env.RUFF_BASE_IMG }},push-by-digest=true,name-canonical=true,push=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Export digests
-        env:
-          digest: ${{ steps.build.outputs.digest }}
-        run: |
-          mkdir -p /tmp/digests
-          touch "/tmp/digests/${digest#sha256:}"
-
-      - name: Upload digests
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: digests-${{ env.PLATFORM_TUPLE }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
-  docker-publish:
-    name: Publish Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-build
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # The printf will expand the base image with the `<RUFF_BASE_IMG>@sha256:<sha256> ...` for each sha256 in the directory
-        # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
-        run: |
-          # shellcheck disable=SC2046
-          docker buildx imagetools create \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)
-
-  docker-publish-extra:
-    name: Publish additional Docker image based on ${{ matrix.image-mapping }}
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    strategy:
-      fail-fast: false
-      matrix:
-        # Mapping of base image followed by a comma followed by one or more base tags (comma separated)
-        # Note, org.opencontainers.image.version label will use the first base tag (use the most specific tag first)
-        image-mapping:
-          - alpine:3.21,alpine3.21,alpine
-          - debian:bookworm-slim,bookworm-slim,debian-slim
-          - buildpack-deps:bookworm,bookworm,debian
-    steps:
-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
-
-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Generate Dynamic Dockerfile Tags
-        shell: bash
-        env:
-          TAG_VALUE: ${{ fromJson(inputs.plan).announcement_tag }}
-        run: |
-          set -euo pipefail
-
-          # Extract the image and tags from the matrix variable
-          IFS=',' read -r BASE_IMAGE BASE_TAGS <<< "${{ matrix.image-mapping }}"
-
-          # Generate Dockerfile content
-          cat <<EOF > Dockerfile
-          FROM ${BASE_IMAGE}
-          COPY --from=${RUFF_BASE_IMG}:latest /ruff /usr/local/bin/ruff
-          ENTRYPOINT []
-          CMD ["/usr/local/bin/ruff"]
-          EOF
-
-          # Initialize a variable to store all tag docker metadata patterns
-          TAG_PATTERNS=""
-
-          # Loop through all base tags and append its docker metadata pattern to the list
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          IFS=','; for TAG in ${BASE_TAGS}; do
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ version }},suffix=-${TAG},value=${TAG_VALUE}\n"
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ major }}.{{ minor }},suffix=-${TAG},value=${TAG_VALUE}\n"
-            TAG_PATTERNS="${TAG_PATTERNS}type=raw,value=${TAG}\n"
-          done
-
-          # Remove the trailing newline from the pattern list
-          TAG_PATTERNS="${TAG_PATTERNS%\\n}"
-
-          # Export image cache name
-          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> "$GITHUB_ENV"
-
-          # Export tag patterns using the multiline env var syntax
-          {
-            echo "TAG_PATTERNS<<EOF"
-            echo -e "${TAG_PATTERNS}"
-            echo EOF
-          } >> "$GITHUB_ENV"
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
-        # ghcr.io prefers index level annotations
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          flavor: |
-            latest=false
-          tags: |
-            ${{ env.TAG_PATTERNS }}
-
-      - name: Build and push
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          # We do not really need to cache here as the Dockerfile is tiny
-          #cache-from: type=gha,scope=ruff-${{ env.IMAGE_REF }}
-          #cache-to: type=gha,mode=min,scope=ruff-${{ env.IMAGE_REF }}
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          annotations: ${{ steps.meta.outputs.annotations }}
-
-  # This is effectively a duplicate of `docker-publish` to make https://github.com/astral-sh/ruff/pkgs/container/ruff
-  # show the ruff base image first since GitHub always shows the last updated image digests
-  # This works by annotating the original digests (previously non-annotated) which triggers an update to ghcr.io
-  docker-republish:
-    name: Annotate Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish-extra
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3.10.0
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@902fa8ec7d6ecbf8d84d538b9b233a880e428804 # v5.7.0
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3.4.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The readarray part is used to make sure the quoting and special characters are preserved on expansion (e.g. spaces)
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # The printf will expand the base image with the `<RUFF_BASE_IMG>@sha256:<sha256> ...` for each sha256 in the directory
-        # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
-        run: |
-          readarray -t lines <<< "$DOCKER_METADATA_OUTPUT_ANNOTATIONS"; annotations=(); for line in "${lines[@]}"; do annotations+=(--annotation "$line"); done
-
-          # shellcheck disable=SC2046
-          docker buildx imagetools create \
-            "${annotations[@]}" \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf "${RUFF_BASE_IMG}@sha256:%s " *)
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
--- a/.github/workflows/daily_fuzz.yaml
+++ b/.github/workflows/daily_fuzz.yaml
@@ -1,78 +0,0 @@
-name: Daily parser fuzz
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 0 * * *"
-  pull_request:
-    paths:
-      - ".github/workflows/daily_fuzz.yaml"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-  PACKAGE_NAME: ruff
-  FORCE_COLOR: 1
-
-jobs:
-  fuzz:
-    name: Fuzz
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-      - uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v6.1.0
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install mold"
-        uses: rui314/setup-mold@67424c1b3680e35255d95971cbd5de0047bf31c3 # v1
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-      - name: Build ruff
-        # A debug build means the script runs slower once it gets started,
-        # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
-        run: cargo build --locked
-      - name: Fuzz
-        run: |
-          # shellcheck disable=SC2046
-          (
-            uvx \
-            --python=3.12 \
-            --from=./python/py-fuzzer \
-            fuzz \
-            --test-executable=target/debug/ruff \
-            --bin=ruff \
-            $(shuf -i 0-9999999999999999999 -n 1000)
-          )
-
-  create-issue-on-failure:
-    name: Create an issue if the daily fuzz surfaced any bugs
-    runs-on: ubuntu-latest
-    needs: fuzz
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.fuzz.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Daily parser fuzz failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
-              labels: ["bug", "parser", "fuzzer"],
-            })
--- a/.github/workflows/flake8-to-ruff.yaml
+++ b/.github/workflows/flake8-to-ruff.yaml
@@ -0,0 +1,298 @@
+name: "[flake8-to-ruff] Release"
+
+on: workflow_dispatch
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: flake8-to-ruff
+  CRATE_NAME: flake8_to_ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - x86_64
+        uses: messense/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - x86_64
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - universal2
+        uses: messense/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - universal2
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }} -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: Publish to PyPi
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.FLAKE8_TO_RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *
--- a/.github/workflows/mypy_primer.yaml
+++ b/.github/workflows/mypy_primer.yaml
@@ -1,101 +0,0 @@
-name: Run mypy_primer
-
-permissions: {}
-
-on:
-  pull_request:
-    paths:
-      - "crates/ty*/**"
-      - "crates/ruff_db"
-      - "crates/ruff_python_ast"
-      - "crates/ruff_python_parser"
-      - ".github/workflows/mypy_primer.yaml"
-      - ".github/workflows/mypy_primer_comment.yaml"
-      - "Cargo.lock"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-  RUST_BACKTRACE: 1
-
-jobs:
-  mypy_primer:
-    name: Run mypy_primer
-    runs-on: depot-ubuntu-22.04-32
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          path: ruff
-          fetch-depth: 0
-          persist-credentials: false
-
-      - name: Install the latest version of uv
-        uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v6.1.0
-
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-        with:
-          workspaces: "ruff"
-
-      - name: Install Rust toolchain
-        run: rustup show
-
-      - name: Run mypy_primer
-        shell: bash
-        run: |
-          cd ruff
-
-          echo "Enabling mypy primer specific configuration overloads (see .github/mypy-primer-ty.toml)"
-          mkdir -p ~/.config/ty
-          cp .github/mypy-primer-ty.toml ~/.config/ty/ty.toml
-
-          PRIMER_SELECTOR="$(paste -s -d'|' crates/ty_python_semantic/resources/primer/good.txt)"
-
-          echo "new commit"
-          git rev-list --format=%s --max-count=1 "$GITHUB_SHA"
-
-          MERGE_BASE="$(git merge-base "$GITHUB_SHA" "origin/$GITHUB_BASE_REF")"
-          git checkout -b base_commit "$MERGE_BASE"
-          echo "base commit"
-          git rev-list --format=%s --max-count=1 base_commit
-
-          cd ..
-
-          echo "Project selector: $PRIMER_SELECTOR"
-          # Allow the exit code to be 0 or 1, only fail for actual mypy_primer crashes/bugs
-          uvx \
-            --from="git+https://github.com/hauntsaninja/mypy_primer@01a7ca325f674433c58e02416a867178d1571128" \
-            mypy_primer \
-            --repo ruff \
-            --type-checker ty \
-            --old base_commit \
-            --new "$GITHUB_SHA" \
-            --project-selector "/($PRIMER_SELECTOR)\$" \
-            --output concise \
-            --debug > mypy_primer.diff || [ $? -eq 1 ]
-
-          # Output diff with ANSI color codes
-          cat mypy_primer.diff
-
-          # Remove ANSI color codes before uploading
-          sed -ie 's/\x1b\[[0-9;]*m//g' mypy_primer.diff
-
-          echo ${{ github.event.number }} > pr-number
-
-      - name: Upload diff
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: mypy_primer_diff
-          path: mypy_primer.diff
-
-      - name: Upload pr-number
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: pr-number
-          path: pr-number
--- a/.github/workflows/mypy_primer_comment.yaml
+++ b/.github/workflows/mypy_primer_comment.yaml
@@ -1,97 +0,0 @@
-name: PR comment (mypy_primer)
-
-on: # zizmor: ignore[dangerous-triggers]
-  workflow_run:
-    workflows: [Run mypy_primer]
-    types: [completed]
-  workflow_dispatch:
-    inputs:
-      workflow_run_id:
-        description: The mypy_primer workflow that triggers the workflow run
-        required: true
-
-jobs:
-  comment:
-    runs-on: ubuntu-24.04
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: Download PR number
-        with:
-          name: pr-number
-          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Parse pull request number
-        id: pr-number
-        run: |
-          if [[ -f pr-number ]]
-          then
-            echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
-          fi
-
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: "Download mypy_primer results"
-        id: download-mypy_primer_diff
-        if: steps.pr-number.outputs.pr-number
-        with:
-          name: mypy_primer_diff
-          workflow: mypy_primer.yaml
-          pr: ${{ steps.pr-number.outputs.pr-number }}
-          path: pr/mypy_primer_diff
-          workflow_conclusion: completed
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Generate comment content
-        id: generate-comment
-        if: steps.download-mypy_primer_diff.outputs.found_artifact == 'true'
-        run: |
-          # Guard against malicious mypy_primer results that symlink to a secret
-          # file on this runner
-          if [[ -L pr/mypy_primer_diff/mypy_primer.diff ]]
-          then
-              echo "Error: mypy_primer.diff cannot be a symlink"
-              exit 1
-          fi
-
-          # Note this identifier is used to find the comment to update on
-          # subsequent runs
-          echo '<!-- generated-comment mypy_primer -->' >> comment.txt
-
-          echo '## `mypy_primer` results' >> comment.txt
-          if [ -s "pr/mypy_primer_diff/mypy_primer.diff" ]; then
-            echo '<details>' >> comment.txt
-            echo '<summary>Changes were detected when running on open source projects</summary>' >> comment.txt
-            echo '' >> comment.txt
-            echo '```diff' >> comment.txt
-            cat pr/mypy_primer_diff/mypy_primer.diff >> comment.txt
-            echo '```' >> comment.txt
-            echo '</details>' >> comment.txt
-          else
-            echo 'No ecosystem changes detected ✅' >> comment.txt
-          fi
-
-          echo 'comment<<EOF' >> "$GITHUB_OUTPUT"
-          cat comment.txt >> "$GITHUB_OUTPUT"
-          echo 'EOF' >> "$GITHUB_OUTPUT"
-
-      - name: Find existing comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3.1.0
-        if: steps.generate-comment.outcome == 'success'
-        id: find-comment
-        with:
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          comment-author: "github-actions[bot]"
-          body-includes: "<!-- generated-comment mypy_primer -->"
-
-      - name: Create or update comment
-        if: steps.find-comment.outcome == 'success'
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4
-        with:
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          body-path: comment.txt
-          edit-mode: replace
--- a/.github/workflows/notify-dependents.yml
+++ b/.github/workflows/notify-dependents.yml
@@ -1,29 +0,0 @@
-# Notify downstream repositories of a new release.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: "[ruff] Notify dependents"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  update-dependents:
-    name: Notify dependents
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Update pre-commit mirror"
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
-        with:
-          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
-          script: |
-            github.rest.actions.createWorkflowDispatch({
-              owner: 'astral-sh',
-              repo: 'ruff-pre-commit',
-              workflow_id: 'main.yml',
-              ref: 'main',
-            })
--- a/.github/workflows/pr-comment.yaml
+++ b/.github/workflows/pr-comment.yaml
@@ -1,88 +0,0 @@
-name: Ecosystem check comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-  workflow_dispatch:
-    inputs:
-      workflow_run_id:
-        description: The ecosystem workflow that triggers the workflow run
-        required: true
-
-jobs:
-  comment:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: Download pull request number
-        with:
-          name: pr-number
-          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Parse pull request number
-        id: pr-number
-        run: |
-          if [[ -f pr-number ]]
-          then
-            echo "pr-number=$(<pr-number)" >> "$GITHUB_OUTPUT"
-          fi
-
-      - uses: dawidd6/action-download-artifact@20319c5641d495c8a52e688b7dc5fada6c3a9fbc # v8
-        name: "Download ecosystem results"
-        id: download-ecosystem-result
-        if: steps.pr-number.outputs.pr-number
-        with:
-          name: ecosystem-result
-          workflow: ci.yaml
-          pr: ${{ steps.pr-number.outputs.pr-number }}
-          path: pr/ecosystem
-          workflow_conclusion: completed
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Generate comment content
-        id: generate-comment
-        if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
-        run: |
-          # Guard against malicious ecosystem results that symlink to a secret
-          # file on this runner
-          if [[ -L pr/ecosystem/ecosystem-result ]]
-          then
-              echo "Error: ecosystem-result cannot be a symlink"
-              exit 1
-          fi
-
-          # Note this identifier is used to find the comment to update on
-          # subsequent runs
-          echo '<!-- generated-comment ecosystem -->' >> comment.txt
-
-          echo '## `ruff-ecosystem` results' >> comment.txt
-          cat pr/ecosystem/ecosystem-result >> comment.txt
-          echo "" >> comment.txt
-
-          echo 'comment<<EOF' >> "$GITHUB_OUTPUT"
-          cat comment.txt >> "$GITHUB_OUTPUT"
-          echo 'EOF' >> "$GITHUB_OUTPUT"
-
-      - name: Find existing comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3.1.0
-        if: steps.generate-comment.outcome == 'success'
-        id: find-comment
-        with:
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          comment-author: "github-actions[bot]"
-          body-includes: "<!-- generated-comment ecosystem -->"
-
-      - name: Create or update comment
-        if: steps.find-comment.outcome == 'success'
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4
-        with:
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          body-path: comment.txt
-          edit-mode: replace
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -1,144 +0,0 @@
-# Publish the Ruff documentation.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: mkdocs
-
-on:
-  workflow_dispatch:
-    inputs:
-      ref:
-        description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
-        default: ""
-        type: string
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  mkdocs:
-    runs-on: ubuntu-latest
-    env:
-      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          ref: ${{ inputs.ref }}
-          persist-credentials: true
-
-      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
-        with:
-          python-version: 3.12
-
-      - name: "Set docs version"
-        env:
-          version: ${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}
-        run: |
-          # if version is missing, use 'latest'
-          if [ -z "$version" ]; then
-            echo "Using 'latest' as version"
-            version="latest"
-          fi
-
-          # Use version as display name for now
-          display_name="$version"
-
-          echo "version=$version" >> "$GITHUB_ENV"
-          echo "display_name=$display_name" >> "$GITHUB_ENV"
-
-      - name: "Set branch name"
-        run: |
-          timestamp="$(date +%s)"
-
-          # create branch_display_name from display_name by replacing all
-          # characters disallowed in git branch names with hyphens
-          branch_display_name="$(echo "${display_name}" | tr -c '[:alnum:]._' '-' | tr -s '-')"
-
-          echo "branch_name=update-docs-$branch_display_name-$timestamp" >> "$GITHUB_ENV"
-          echo "timestamp=$timestamp" >> "$GITHUB_ENV"
-
-      - name: "Add SSH key"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
-        with:
-          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
-
-      - name: "Install Rust toolchain"
-        run: rustup show
-
-      - uses: Swatinem/rust-cache@9d47c6ad4b02e050fd481d890b2ea34778fd09d6 # v2.7.8
-
-      - name: "Install Insiders dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: pip install -r docs/requirements-insiders.txt
-
-      - name: "Install dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: pip install -r docs/requirements.txt
-
-      - name: "Copy README File"
-        run: |
-          python scripts/transform_readme.py --target mkdocs
-          python scripts/generate_mkdocs.py
-
-      - name: "Build Insiders docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: mkdocs build --strict -f mkdocs.insiders.yml
-
-      - name: "Build docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: mkdocs build --strict -f mkdocs.public.yml
-
-      - name: "Clone docs repo"
-        run: git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
-
-      - name: "Copy docs"
-        run: rm -rf astral-docs/site/ruff && mkdir -p astral-docs/site && cp -r site/ruff astral-docs/site/
-
-      - name: "Commit docs"
-        working-directory: astral-docs
-        run: |
-          git config user.name "astral-docs-bot"
-          git config user.email "176161322+astral-docs-bot@users.noreply.github.com"
-
-          git checkout -b "${branch_name}"
-          git add site/ruff
-          git commit -m "Update ruff documentation for $version"
-
-      - name: "Create Pull Request"
-        working-directory: astral-docs
-        env:
-          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
-        run: |
-          # set the PR title
-          pull_request_title="Update ruff documentation for ${display_name}"
-
-          # Delete any existing pull requests that are open for this version
-          # by checking against pull_request_title because the new PR will
-          # supersede the old one.
-          gh pr list --state open --json title --jq '.[] | select(.title == "$pull_request_title") | .number' | \
-            xargs -I {} gh pr close {}
-
-          # push the branch to GitHub
-          git push origin "${branch_name}"
-
-          # create the PR
-          gh pr create \
-            --base=main \
-            --head="${branch_name}" \
-            --title="${pull_request_title}" \
-            --body="Automated documentation update for ${display_name}" \
-            --label="documentation"
-
-      - name: "Merge Pull Request"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        working-directory: astral-docs
-        env:
-          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
-        run: |
-          # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
-          # give the PR a few seconds to be created before trying to auto-merge it
-          sleep 10
-          gh pr merge --squash "${branch_name}"
--- a/.github/workflows/publish-playground.yml
+++ b/.github/workflows/publish-playground.yml
@@ -1,54 +0,0 @@
-# Publish the Ruff playground.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: "[Playground] Release"
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    env:
-      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-        with:
-          node-version: 22
-          cache: "npm"
-          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
-      - name: "Install Node dependencies"
-        run: npm ci
-        working-directory: playground
-      - name: "Run TypeScript checks"
-        run: npm run check
-        working-directory: playground
-      - name: "Build Ruff playground"
-        run: npm run build --workspace ruff-playground
-        working-directory: playground
-      - name: "Deploy to Cloudflare Pages"
-        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65 # v3.14.1
-        with:
-          apiToken: ${{ secrets.CF_API_TOKEN }}
-          accountId: ${{ secrets.CF_ACCOUNT_ID }}
-          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
-          command: pages deploy playground/ruff/dist --project-name=ruff-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}
--- a/.github/workflows/publish-pypi.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -1,32 +0,0 @@
-# Publish a release to PyPI.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish job
-# within `cargo-dist`.
-name: "[ruff] Publish to PyPI"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  pypi-publish:
-    name: Upload to PyPI
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    permissions:
-      # For PyPI's trusted publishing.
-      id-token: write
-    steps:
-      - name: "Install uv"
-        uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v6.1.0
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          pattern: wheels-*
-          path: wheels
-          merge-multiple: true
-      - name: Publish to PyPi
-        run: uv publish -v wheels/*
--- a/.github/workflows/publish-ty-playground.yml
+++ b/.github/workflows/publish-ty-playground.yml
@@ -1,58 +0,0 @@
-# Publish the ty playground.
-name: "[ty Playground] Release"
-
-permissions: {}
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - "crates/ty*/**"
-      - "crates/ruff_db/**"
-      - "crates/ruff_python_ast/**"
-      - "crates/ruff_python_parser/**"
-      - "playground/**"
-      - ".github/workflows/publish-ty-playground.yml"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    env:
-      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-        with:
-          node-version: 22
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
-      - name: "Install Node dependencies"
-        run: npm ci
-        working-directory: playground
-      - name: "Run TypeScript checks"
-        run: npm run check
-        working-directory: playground
-      - name: "Build ty playground"
-        run: npm run build --workspace ty-playground
-        working-directory: playground
-      - name: "Deploy to Cloudflare Pages"
-        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65 # v3.14.1
-        with:
-          apiToken: ${{ secrets.CF_API_TOKEN }}
-          accountId: ${{ secrets.CF_ACCOUNT_ID }}
-          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
-          command: pages deploy playground/ty/dist --project-name=ty-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}
--- a/.github/workflows/publish-wasm.yml
+++ b/.github/workflows/publish-wasm.yml
@@ -1,59 +0,0 @@
-# Build and publish ruff-api for wasm.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish
-# job within `cargo-dist`.
-name: "Build and publish wasm"
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  ruff_wasm:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    strategy:
-      matrix:
-        target: [web, bundler, nodejs]
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa # v0.4.0
-        with:
-          version: v0.13.1
-      - uses: jetli/wasm-bindgen-action@20b33e20595891ab1a0ed73145d8a21fc96e7c29 # v0.2.0
-      - name: "Run wasm-pack build"
-        run: wasm-pack build --target ${{ matrix.target }} crates/ruff_wasm
-      - name: "Rename generated package"
-        run: | # Replace the package name w/ jq
-          jq '.name="@astral-sh/ruff-wasm-${{ matrix.target }}"' crates/ruff_wasm/pkg/package.json > /tmp/package.json
-          mv /tmp/package.json crates/ruff_wasm/pkg
-      - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-        with:
-          node-version: 20
-          registry-url: "https://registry.npmjs.org"
-      - name: "Publish (dry-run)"
-        if: ${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --dry-run crates/ruff_wasm/pkg
-      - name: "Publish"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --provenance --access public crates/ruff_wasm/pkg
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,306 +0,0 @@
-# This file was autogenerated by dist: https://github.com/astral-sh/cargo-dist
-#
-# Copyright 2022-2024, axodotdev
-# Copyright 2025 Astral Software Inc.
-# SPDX-License-Identifier: MIT or Apache-2.0
-#
-# CI that:
-#
-# * checks for a Git Tag that looks like a release
-# * builds artifacts with dist (archives, installers, hashes)
-# * uploads those artifacts to temporary workflow zip
-# * on success, uploads the artifacts to a GitHub Release
-#
-# Note that the GitHub Release will be created with a generated
-# title/body based on your changelogs.
-
-name: Release
-permissions:
-  "contents": "write"
-
-# This task will run whenever you workflow_dispatch with a tag that looks like a version
-# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
-# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
-# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
-# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
-#
-# If PACKAGE_NAME is specified, then the announcement will be for that
-# package (erroring out if it doesn't have the given version or isn't dist-able).
-#
-# If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (dist-able) packages in the workspace with that version (this mode is
-# intended for workspaces with only one dist-able package, or with all dist-able
-# packages versioned/released in lockstep).
-#
-# If you push multiple tags at once, separate instances of this workflow will
-# spin up, creating an independent announcement for each one. However, GitHub
-# will hard limit this to 3 tags per commit, as it will assume more tags is a
-# mistake.
-#
-# If there's a prerelease-style suffix to the version, then the release(s)
-# will be marked as a prerelease.
-on:
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: Release Tag
-        required: true
-        default: dry-run
-        type: string
-
-jobs:
-  # Run 'dist plan' (or host) to determine what tasks we need to do
-  plan:
-    runs-on: "depot-ubuntu-latest-4"
-    outputs:
-      val: ${{ steps.plan.outputs.manifest }}
-      tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
-      tag-flag: ${{ inputs.tag && inputs.tag != 'dry-run' && format('--tag={0}', inputs.tag) || '' }}
-      publishing: ${{ inputs.tag && inputs.tag != 'dry-run' }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install dist
-        # we specify bash to get pipefail; it guards against the `curl` command
-        # failing. otherwise `sh` won't catch that `curl` returned non-0
-        shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/astral-sh/cargo-dist/releases/download/v0.28.5-prerelease.1/cargo-dist-installer.sh | sh"
-      - name: Cache dist
-        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/dist
-      # sure would be cool if github gave us proper conditionals...
-      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
-      # functionality based on whether this is a pull_request, and whether it's from a fork.
-      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
-      # but also really annoying to build CI around when it needs secrets to work right.)
-      - id: plan
-        run: |
-          dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-          echo "dist ran successfully"
-          cat plan-dist-manifest.json
-          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
-        with:
-          name: artifacts-plan-dist-manifest
-          path: plan-dist-manifest.json
-
-  custom-build-binaries:
-    needs:
-      - plan
-    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
-    uses: ./.github/workflows/build-binaries.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-build-docker:
-    needs:
-      - plan
-    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
-    uses: ./.github/workflows/build-docker.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    permissions:
-      "contents": "read"
-      "packages": "write"
-
-  # Build and package all the platform-agnostic(ish) things
-  build-global-artifacts:
-    needs:
-      - plan
-      - custom-build-binaries
-      - custom-build-docker
-    runs-on: "depot-ubuntu-latest-4"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
-    steps:
-      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
-      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
-      - name: Fetch local artifacts
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      - id: cargo-dist
-        shell: bash
-        run: |
-          dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "dist ran successfully"
-
-          # Parse out what we just built and upload it to scratch storage
-          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
-          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
-          echo "EOF" >> "$GITHUB_OUTPUT"
-
-          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
-      - name: "Upload artifacts"
-        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
-        with:
-          name: artifacts-build-global
-          path: |
-            ${{ steps.cargo-dist.outputs.paths }}
-            ${{ env.BUILD_MANIFEST_NAME }}
-  # Determines if we should publish/announce
-  host:
-    needs:
-      - plan
-      - custom-build-binaries
-      - custom-build-docker
-      - build-global-artifacts
-    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
-    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.custom-build-binaries.result == 'skipped' || needs.custom-build-binaries.result == 'success') && (needs.custom-build-docker.result == 'skipped' || needs.custom-build-docker.result == 'success') }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "depot-ubuntu-latest-4"
-    outputs:
-      val: ${{ steps.host.outputs.manifest }}
-    steps:
-      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
-        with:
-          persist-credentials: false
-          submodules: recursive
-      - name: Install cached dist
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/dist
-      # Fetch artifacts from scratch-storage
-      - name: Fetch artifacts
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      # This is a harmless no-op for GitHub Releases, hosting for that happens in "announce"
-      - id: host
-        shell: bash
-        run: |
-          dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
-          echo "artifacts uploaded and released successfully"
-          cat dist-manifest.json
-          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
-        with:
-          # Overwrite the previous copy
-          name: artifacts-dist-manifest
-          path: dist-manifest.json
-
-  custom-publish-pypi:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-pypi.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "id-token": "write"
-      "packages": "write"
-
-  custom-publish-wasm:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-wasm.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "contents": "read"
-      "id-token": "write"
-      "packages": "write"
-
-  # Create a GitHub Release while uploading all files to it
-  announce:
-    needs:
-      - plan
-      - host
-      - custom-publish-pypi
-      - custom-publish-wasm
-    # use "always() && ..." to allow us to wait for all publish jobs while
-    # still allowing individual publish jobs to skip themselves (for prereleases).
-    # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
-    runs-on: "depot-ubuntu-latest-4"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
-        with:
-          persist-credentials: false
-          submodules: recursive
-      # Create a GitHub Release while uploading all files to it
-      - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
-        with:
-          pattern: artifacts-*
-          path: artifacts
-          merge-multiple: true
-      - name: Cleanup
-        run: |
-          # Remove the granular manifests
-          rm -f artifacts/*-dist-manifest.json
-      - name: Create GitHub Release
-        env:
-          PRERELEASE_FLAG: "${{ fromJson(needs.host.outputs.val).announcement_is_prerelease && '--prerelease' || '' }}"
-          ANNOUNCEMENT_TITLE: "${{ fromJson(needs.host.outputs.val).announcement_title }}"
-          ANNOUNCEMENT_BODY: "${{ fromJson(needs.host.outputs.val).announcement_github_body }}"
-          RELEASE_COMMIT: "${{ github.sha }}"
-        run: |
-          # Write and read notes from a file to avoid quoting breaking things
-          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
-
-          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
-
-  custom-notify-dependents:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/notify-dependents.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-publish-docs:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/publish-docs.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-publish-playground:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/publish-playground.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
--- a/.github/workflows/ruff.yaml
+++ b/.github/workflows/ruff.yaml
@@ -0,0 +1,301 @@
+name: "[ruff] Release"
+
+on:
+  create:
+    tags:
+      - v*
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - x86_64
+        uses: messense/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - x86_64
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - universal2
+        uses: messense/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - universal2
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }}
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
+    if: "startsWith(github.ref, 'refs/tags/')"
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: Publish to PyPi
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *
--- a/.github/workflows/sync_typeshed.yaml
+++ b/.github/workflows/sync_typeshed.yaml
@@ -1,83 +0,0 @@
-name: Sync typeshed
-
-on:
-  workflow_dispatch:
-  schedule:
-    # Run on the 1st and the 15th of every month:
-    - cron: "0 0 1,15 * *"
-
-env:
-  FORCE_COLOR: 1
-  GH_TOKEN: ${{ github.token }}
-
-jobs:
-  sync:
-    name: Sync typeshed
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        name: Checkout Ruff
-        with:
-          path: ruff
-          persist-credentials: true
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        name: Checkout typeshed
-        with:
-          repository: python/typeshed
-          path: typeshed
-          persist-credentials: false
-      - name: Setup git
-        run: |
-          git config --global user.name typeshedbot
-          git config --global user.email '<>'
-      - name: Sync typeshed
-        id: sync
-        run: |
-          rm -rf ruff/crates/ty_vendored/vendor/typeshed
-          mkdir ruff/crates/ty_vendored/vendor/typeshed
-          cp typeshed/README.md ruff/crates/ty_vendored/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/ty_vendored/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/ty_vendored/vendor/typeshed/stdlib
-          rm -rf ruff/crates/ty_vendored/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/ty_vendored/vendor/typeshed/source_commit.txt
-      - name: Commit the changes
-        id: commit
-        if: ${{ steps.sync.outcome == 'success' }}
-        run: |
-          cd ruff
-          git checkout -b typeshedbot/sync-typeshed
-          git add .
-          git diff --staged --quiet || git commit -m "Sync typeshed. Source commit: https://github.com/python/typeshed/commit/$(git -C ../typeshed rev-parse HEAD)"
-      - name: Create a PR
-        if: ${{ steps.sync.outcome == 'success' && steps.commit.outcome == 'success' }}
-        run: |
-          cd ruff
-          git push --force origin typeshedbot/sync-typeshed
-          gh pr list --repo "$GITHUB_REPOSITORY" --head typeshedbot/sync-typeshed --json id --jq length | grep 1 && exit 0 # exit if there is existing pr
-          gh pr create --title "Sync vendored typeshed stubs" --body "Close and reopen this PR to trigger CI" --label "internal"
-
-  create-issue-on-failure:
-    name: Create an issue if the typeshed sync failed
-    runs-on: ubuntu-latest
-    needs: [sync]
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.sync.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Automated typeshed sync failed on ${new Date().toDateString()}`,
-              body: "Run listed here: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}",
-              labels: ["bug", "ty"],
-            })
--- a/.github/zizmor.yml
+++ b/.github/zizmor.yml
@@ -1,19 +0,0 @@
-# Configuration for the zizmor static analysis tool, run via pre-commit in CI
-# https://woodruffw.github.io/zizmor/configuration/
-#
-# TODO: can we remove the ignores here so that our workflows are more secure?
-rules:
-  dangerous-triggers:
-    ignore:
-      - pr-comment.yaml
-  cache-poisoning:
-    ignore:
-      - build-docker.yml
-      - publish-playground.yml
-  excessive-permissions:
-    # it's hard to test what the impact of removing these ignores would be
-    # without actually running the release workflow...
-    ignore:
-      - build-docker.yml
-      - publish-playground.yml
-      - publish-docs.yml
--- a/.gitignore
+++ b/.gitignore
@@ -1,37 +1,6 @@
-# Benchmarking cpython (CONTRIBUTING.md)
-crates/ruff_linter/resources/test/cpython
-# generate_mkdocs.py
-mkdocs.generated.yml
-# check_ecosystem.py
-ruff-old
-github_search*.jsonl
-# update_schemastore.py
-schemastore
-# `maturin develop` and ecosystem_all_check.sh
-.venv*
-# Formatter debugging (crates/ruff_python_formatter/README.md)
-scratch.*
-# Created by `perf` (CONTRIBUTING.md)
-perf.data
-perf.data.old
-# Created by `flamegraph` (CONTRIBUTING.md)
-flamegraph.svg
-# Additional target directories that don't invalidate the main compile cache when changing linker settings,
-# e.g. `CARGO_TARGET_DIR=target-maturin maturin build --release --strip` or
-# `CARGO_TARGET_DIR=target-llvm-lines RUSTFLAGS="-Csymbol-mangling-version=v0" cargo llvm-lines -p ruff --lib`
-/target*
-
-# samply profiles
-profile.json
-
-# tracing-flame traces
-tracing.folded
-tracing-flamechart.svg
-tracing-flamegraph.svg
-
-# insta
-*.rs.pending-snap
-
+# Local cache
+.ruff_cache
+resources/test/cpython

 ###
 # Rust.gitignore
@@ -104,7 +73,6 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
-repos/

 # Translations
 *.mo
@@ -213,17 +181,3 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
-.vimspector.json
-
-# Visual Studio Code
-.vscode/
-
-# VIM
-.*.sw?
-.sw?
-
-# Custom re-inclusions for the resolver test cases
-!crates/ruff_python_resolver/resources/test/airflow/venv/
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib/python3.11/site-packages/_watchdog_fsevents.cpython-311-darwin.so
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib/python3.11/site-packages/orjson/orjson.cpython-311-darwin.so
--- a/.ignore
+++ b/.ignore
@@ -1 +0,0 @@
-!/.github/
--- a/.markdownlint.yaml
+++ b/.markdownlint.yaml
@@ -1,35 +0,0 @@
-# default to true for all rules
-default: true
-
-# MD007/unordered-list-indent
-MD007:
-  indent: 4
-
-# MD033/no-inline-html
-MD033: false
-
-# MD041/first-line-h1
-MD041: false
-
-# MD013/line-length
-MD013: false
-
-# MD014/commands-show-output
-MD014: false
-
-# MD024/no-duplicate-heading
-MD024:
-  # Allow when nested under different parents e.g. CHANGELOG.md
-  siblings_only: true
-
-# MD046/code-block-style
-#
-# Ignore this because it conflicts with the code block style used in content
-# tabs of mkdocs-material which is to add a blank line after the content title.
-#
-# Ref: https://github.com/astral-sh/ruff/pull/15011#issuecomment-2544790854
-MD046: false
-
-# Link text should be descriptive
-# Disallows link text like *here* which is annoying.
-MD059: false
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,131 +1,10 @@
-fail_fast: false
-
-exclude: |
-  (?x)^(
-    .github/workflows/release.yml|
-    crates/ty_vendored/vendor/.*|
-    crates/ty_project/resources/.*|
-    crates/ty/docs/(configuration|rules|cli).md|
-    crates/ruff_benchmark/resources/.*|
-    crates/ruff_linter/resources/.*|
-    crates/ruff_linter/src/rules/.*/snapshots/.*|
-    crates/ruff_notebook/resources/.*|
-    crates/ruff_server/resources/.*|
-    crates/ruff/resources/.*|
-    crates/ruff_python_formatter/resources/.*|
-    crates/ruff_python_formatter/tests/snapshots/.*|
-    crates/ruff_python_resolver/resources/.*|
-    crates/ruff_python_resolver/tests/snapshots/.*
-  )$
-
 repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.108
    hooks:
-      - id: check-merge-conflict
+      - id: ruff

  - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.24.1
+    rev: v0.10.1
    hooks:
      - id: validate-pyproject
-
-  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.22
-    hooks:
-      - id: mdformat
-        additional_dependencies:
-          - mdformat-mkdocs==4.0.0
-          - mdformat-footnote==0.1.1
-        exclude: |
-          (?x)^(
-            docs/formatter/black\.md
-            | docs/\w+\.md
-          )$
-
-  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.45.0
-    hooks:
-      - id: markdownlint-fix
-        exclude: |
-          (?x)^(
-            docs/formatter/black\.md
-            | docs/\w+\.md
-          )$
-
-  - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.19.1
-    hooks:
-      - id: blacken-docs
-        args: ["--pyi", "--line-length", "130"]
-        files: '^crates/.*/resources/mdtest/.*\.md'
-        exclude: |
-          (?x)^(
-            .*?invalid(_.+)*_syntax\.md
-          )$
-        additional_dependencies:
-          - black==25.1.0
-
-  - repo: https://github.com/crate-ci/typos
-    rev: v1.32.0
-    hooks:
-      - id: typos
-
-  - repo: local
-    hooks:
-      - id: cargo-fmt
-        name: cargo fmt
-        entry: cargo fmt --
-        language: system
-        types: [rust]
-        pass_filenames: false # This makes it a lot faster
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.12
-    hooks:
-      - id: ruff-format
-      - id: ruff
-        args: [--fix, --exit-non-zero-on-fix]
-        types_or: [python, pyi]
-        require_serial: true
-
-  # Prettier
-  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.5.3
-    hooks:
-      - id: prettier
-        types: [yaml]
-
-  # zizmor detects security vulnerabilities in GitHub Actions workflows.
-  # Additional configuration for the tool is found in `.github/zizmor.yml`
-  - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.9.0
-    hooks:
-      - id: zizmor
-
-  - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.33.0
-    hooks:
-      - id: check-github-workflows
-
-  # `actionlint` hook, for verifying correct syntax in GitHub Actions workflows.
-  # Some additional configuration for `actionlint` can be found in `.github/actionlint.yaml`.
-  - repo: https://github.com/rhysd/actionlint
-    rev: v1.7.7
-    hooks:
-      - id: actionlint
-        stages:
-          # This hook is disabled by default, since it's quite slow.
-          # To run all hooks *including* this hook, use `uvx pre-commit run -a --hook-stage=manual`.
-          # To run *just* this hook, use `uvx pre-commit run -a actionlint --hook-stage=manual`.
-          - manual
-        args:
-          - "-ignore=SC2129" # ignorable stylistic lint from shellcheck
-          - "-ignore=SC2016" # another shellcheck lint: seems to have false positives?
-        additional_dependencies:
-          # actionlint has a shellcheck integration which extracts shell scripts in `run:` steps from GitHub Actions
-          # and checks these with shellcheck. This is arguably its most useful feature,
-          # but the integration only works if shellcheck is installed
-          - "github.com/wasilibs/go-shellcheck/cmd/shellcheck@v0.10.0"
-
-ci:
-  skip: [cargo-fmt, dev-generate-all]
--- a/.prettierignore
+++ b/.prettierignore
@@ -1,2 +0,0 @@
-# Auto-generated by `cargo-dist`.
-.github/workflows/release.yml
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer"
-    ]
-}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,6 +0,0 @@
-{
-    "rust-analyzer.check.extraArgs": [
-        "--all-features"
-    ],
-    "rust-analyzer.check.command": "clippy",
-}
--- a/BREAKING_CHANGES.md
+++ b/BREAKING_CHANGES.md
@@ -1,557 +0,0 @@
-# Breaking Changes
-
-## 0.11.0
-
-This is a follow-up to release 0.10.0. Because of a mistake in the release process, the `requires-python` inference changes were not included in that release. Ruff 0.11.0 now includes this change as well as the stabilization of the preview behavior for `PGH004`.
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    In previous versions of Ruff, you could specify your Python version with:
-
-    - The `target-version` option in a `ruff.toml` file or the `[tool.ruff]` section of a pyproject.toml file.
-    - The `project.requires-python` field in a `pyproject.toml` file with a `[tool.ruff]` section.
-
-    These options worked well in most cases, and are still recommended for fine control of the Python version. However, because of the way Ruff discovers config files, `pyproject.toml` files without a `[tool.ruff]` section would be ignored, including the `requires-python` setting. Ruff would then use the default Python version (3.9 as of this writing) instead, which is surprising when you've attempted to request another version.
-
-    In v0.10, config discovery has been updated to address this issue:
-
-    - If Ruff finds a `ruff.toml` file without a `target-version`, it will check
-        for a `pyproject.toml` file in the same directory and respect its
-        `requires-python` version, even if it does not contain a `[tool.ruff]`
-        section.
-    - If Ruff finds a user-level configuration, the `requires-python` field of the closest `pyproject.toml` in a parent directory will take precedence.
-    - If there is no config file (`ruff.toml`or `pyproject.toml` with a
-        `[tool.ruff]` section) in the directory of the file being checked, Ruff will
-        search for the closest `pyproject.toml` in the parent directories and use its
-        `requires-python` setting.
-
-## 0.10.0
-
- **Changes to how the Python version is inferred when a `target-version` is not specified** ([#16319](https://github.com/astral-sh/ruff/pull/16319))
-
-    Because of a mistake in the release process, the `requires-python` inference changes are not included in this release and instead shipped as part of 0.11.0.
-    You can find a description of this change in the 0.11.0 section.
-
- **Updated `TYPE_CHECKING` behavior** ([#16669](https://github.com/astral-sh/ruff/pull/16669))
-
-    Previously, Ruff only recognized typechecking blocks that tested the `typing.TYPE_CHECKING` symbol. Now, Ruff recognizes any local variable named `TYPE_CHECKING`. This release also removes support for the legacy `if 0:` and `if False:` typechecking checks. Use a local `TYPE_CHECKING` variable instead.
-
- **More robust noqa parsing** ([#16483](https://github.com/astral-sh/ruff/pull/16483))
-
-    The syntax for both file-level and in-line suppression comments has been unified and made more robust to certain errors. In most cases, this will result in more suppression comments being read by Ruff, but there are a few instances where previously read comments will now log an error to the user instead. Please refer to the documentation on [_Error suppression_](https://docs.astral.sh/ruff/linter/#error-suppression) for the full specification.
-
- **Avoid unnecessary parentheses around with statements with a single context manager and a trailing comment** ([#14005](https://github.com/astral-sh/ruff/pull/14005))
-
-    This change fixes a bug in the formatter where it introduced unnecessary parentheses around with statements with a single context manager and a trailing comment. This change may result in a change in formatting for some users.
-
- **Bump alpine default tag to 3.21 for derived Docker images** ([#16456](https://github.com/astral-sh/ruff/pull/16456))
-
-    Alpine 3.21 was released in Dec 2024 and is used in the official Alpine-based Python images. Now the ruff:alpine image will use 3.21 instead of 3.20 and ruff:alpine3.20 will no longer be updated.
-
- **\[`unsafe-markup-use`\]: `RUF035` has been recoded to `S704`** ([#15957](https://github.com/astral-sh/ruff/pull/15957))
-
-## 0.9.0
-
-Ruff now formats your code according to the 2025 style guide. As a result, your code might now get formatted differently. See the [changelog](./CHANGELOG.md#090) for a detailed list of changes.
-
-## 0.8.0
-
- **Default to Python 3.9**
-
-    Ruff now defaults to Python 3.9 instead of 3.8 if no explicit Python version is configured using [`ruff.target-version`](https://docs.astral.sh/ruff/settings/#target-version) or [`project.requires-python`](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#python-requires) ([#13896](https://github.com/astral-sh/ruff/pull/13896))
-
- **Changed location of `pydoclint` diagnostics**
-
-    [`pydoclint`](https://docs.astral.sh/ruff/rules/#pydoclint-doc) diagnostics now point to the first-line of the problematic docstring. Previously, this was not the case.
-
-    If you've opted into these preview rules but have them suppressed using
-    [`noqa`](https://docs.astral.sh/ruff/linter/#error-suppression) comments in
-    some places, this change may mean that you need to move the `noqa` suppression
-    comments. Most users should be unaffected by this change.
-
- **Use XDG (i.e. `~/.local/bin`) instead of the Cargo home directory in the standalone installer**
-
-    Previously, Ruff's installer used `$CARGO_HOME` or `~/.cargo/bin` for its target install directory. Now, Ruff will be installed into `$XDG_BIN_HOME`, `$XDG_DATA_HOME/../bin`, or `~/.local/bin` (in that order).
-
-    This change is only relevant to users of the standalone Ruff installer (using the shell or PowerShell script). If you installed Ruff using uv or pip, you should be unaffected.
-
- **Changes to the line width calculation**
-
-    Ruff now uses a new version of the [unicode-width](https://github.com/unicode-rs/unicode-width) Rust crate to calculate the line width. In very rare cases, this may lead to lines containing Unicode characters being reformatted, or being considered too long when they were not before ([`E501`](https://docs.astral.sh/ruff/rules/line-too-long/)).
-
-## 0.7.0
-
- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments
-    ([#12838](https://github.com/astral-sh/ruff/pull/12838), [#13292](https://github.com/astral-sh/ruff/pull/13292)).
-    This was a change that we attempted to make in Ruff v0.6.0, but only partially made due to an error on our part.
-    See the [blog post](https://astral.sh/blog/ruff-v0.7.0) for more details.
- The `useless-try-except` rule (in our `tryceratops` category) has been recoded from `TRY302` to
-    `TRY203` ([#13502](https://github.com/astral-sh/ruff/pull/13502)). This ensures Ruff's code is consistent with
-    the same rule in the [`tryceratops`](https://github.com/guilatrova/tryceratops) linter.
- The `lint.allow-unused-imports` setting has been removed ([#13677](https://github.com/astral-sh/ruff/pull/13677)). Use
-    [`lint.pyflakes.allow-unused-imports`](https://docs.astral.sh/ruff/settings/#lint_pyflakes_allowed-unused-imports)
-    instead.
-
-## 0.6.0
-
- Detect imports in `src` layouts by default for `isort` rules ([#12848](https://github.com/astral-sh/ruff/pull/12848))
-
- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments ([#12838](https://github.com/astral-sh/ruff/pull/12838)).
-
- Lint and format Jupyter Notebook by default ([#12878](https://github.com/astral-sh/ruff/pull/12878)).
-
-    You can disable specific rules for notebooks using [`per-file-ignores`](https://docs.astral.sh/ruff/settings/#lint_per-file-ignores):
-
-    ```toml
-    [tool.ruff.lint.per-file-ignores]
-    "*.ipynb" = ["E501"] # disable line-too-long in notebooks
-    ```
-
-    If you'd prefer to either only lint or only format Jupyter Notebook files, you can use the
-    section-specific `exclude` option to do so. For example, the following would only lint Jupyter
-    Notebook files and not format them:
-
-    ```toml
-    [tool.ruff.format]
-    exclude = ["*.ipynb"]
-    ```
-
-    And, conversely, the following would only format Jupyter Notebook files and not lint them:
-
-    ```toml
-    [tool.ruff.lint]
-    exclude = ["*.ipynb"]
-    ```
-
-    You can completely disable Jupyter Notebook support by updating the [`extend-exclude`](https://docs.astral.sh/ruff/settings/#extend-exclude) setting:
-
-    ```toml
-    [tool.ruff]
-    extend-exclude = ["*.ipynb"]
-    ```
-
-## 0.5.0
-
- Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
- Selecting `ALL` now excludes deprecated rules
- The released archives now include an extra level of nesting, which can be removed with `--strip-components=1` when untarring.
- The release artifact's file name no longer includes the version tag. This enables users to install via `/latest` URLs on GitHub.
-
-## 0.3.0
-
-### Ruff 2024.2 style
-
-The formatter now formats code according to the Ruff 2024.2 style guide. Read the [changelog](./CHANGELOG.md#030) for a detailed list of stabilized style changes.
-
-### `isort`: Use one blank line after imports in typing stub files ([#9971](https://github.com/astral-sh/ruff/pull/9971))
-
-Previously, Ruff used one or two blank lines (or the number configured by `isort.lines-after-imports`) after imports in typing stub files (`.pyi` files).
-The [typing style guide for stubs](https://typing.readthedocs.io/en/latest/source/stubs.html#style-guide) recommends using at most 1 blank line for grouping.
-As of this release, `isort` now always uses one blank line after imports in stub files, the same as the formatter.
-
-### `build` is no longer excluded by default ([#10093](https://github.com/astral-sh/ruff/pull/10093))
-
-Ruff maintains a list of directories and files that are excluded by default. This list now consists of the following patterns:
-
- `.bzr`
- `.direnv`
- `.eggs`
- `.git`
- `.git-rewrite`
- `.hg`
- `.ipynb_checkpoints`
- `.mypy_cache`
- `.nox`
- `.pants.d`
- `.pyenv`
- `.pytest_cache`
- `.pytype`
- `.ruff_cache`
- `.svn`
- `.tox`
- `.venv`
- `.vscode`
- `__pypackages__`
- `_build`
- `buck-out`
- `dist`
- `node_modules`
- `site-packages`
- `venv`
-
-Previously, the `build` directory was included in this list. However, the `build` directory tends to be a not-unpopular directory
-name, and excluding it by default caused confusion. Ruff now no longer excludes `build` except if it is excluded by a `.gitignore` file
-or because it is listed in `extend-exclude`.
-
-### `--format` is no longer a valid `rule` or `linter` command option
-
-Previously, `ruff rule` and `ruff linter` accepted the `--format <FORMAT>` option as an alias for `--output-format`. Ruff no longer
-supports this alias. Please use `ruff rule --output-format <FORMAT>` and `ruff linter --output-format <FORMAT>` instead.
-
-## 0.1.9
-
-### `site-packages` is now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))
-
-Ruff maintains a list of default exclusions, which now consists of the following patterns:
-
- `.bzr`
- `.direnv`
- `.eggs`
- `.git-rewrite`
- `.git`
- `.hg`
- `.ipynb_checkpoints`
- `.mypy_cache`
- `.nox`
- `.pants.d`
- `.pyenv`
- `.pytest_cache`
- `.pytype`
- `.ruff_cache`
- `.svn`
- `.tox`
- `.venv`
- `.vscode`
- `__pypackages__`
- `_build`
- `buck-out`
- `build`
- `dist`
- `node_modules`
- `site-packages`
- `venv`
-
-Previously, the `site-packages` directory was not excluded by default. While `site-packages` tends
-to be excluded anyway by virtue of the `.venv` exclusion, this may not be the case when using Ruff
-from VS Code outside a virtual environment.
-
-## 0.1.0
-
-### The deprecated `format` setting has been removed
-
-Ruff previously used the `format` setting, `--format` CLI option, and `RUFF_FORMAT` environment variable to
-configure the output format of the CLI. This usage was deprecated in `v0.0.291` — the `format` setting is now used
-to control Ruff's code formatting. As of this release:
-
- The `format` setting cannot be used to configure the output format, use `output-format` instead
- The `RUFF_FORMAT` environment variable is ignored, use `RUFF_OUTPUT_FORMAT` instead
- The `--format` option has been removed from `ruff check`, use `--output-format` instead
-
-### Unsafe fixes are not applied by default ([#7769](https://github.com/astral-sh/ruff/pull/7769))
-
-Ruff labels fixes as "safe" and "unsafe". The meaning and intent of your code will be retained when applying safe
-fixes, but the meaning could be changed when applying unsafe fixes. Previously, unsafe fixes were always displayed
-and applied when fixing was enabled. Now, unsafe fixes are hidden by default and not applied. The `--unsafe-fixes`
-flag or `unsafe-fixes` configuration option can be used to enable unsafe fixes.
-
-See the [docs](https://docs.astral.sh/ruff/configuration/#fix-safety) for details.
-
-### Remove formatter-conflicting rules from the default rule set ([#7900](https://github.com/astral-sh/ruff/pull/7900))
-
-Previously, Ruff enabled all implemented rules in Pycodestyle (`E`) by default. Ruff now only includes the
-Pycodestyle prefixes `E4`, `E7`, and `E9` to exclude rules that conflict with automatic formatters. Consequently,
-the stable rule set no longer includes `line-too-long` (`E501`) and `mixed-spaces-and-tabs` (`E101`). Other
-excluded Pycodestyle rules include whitespace enforcement in `E1` and `E2`; these rules are currently in preview, and are already omitted by default.
-
-This change only affects those using Ruff under its default rule set. Users that include `E` in their `select` will experience no change in behavior.
-
-## 0.0.288
-
-### Remove support for emoji identifiers ([#7212](https://github.com/astral-sh/ruff/pull/7212))
-
-Previously, Ruff supported non-standards-compliant emoji identifiers such as `📦 = 1`.
-We decided to remove this non-standard language extension. Ruff now reports syntax errors for invalid emoji identifiers in your code, the same as CPython.
-
-### Improved GitLab fingerprints ([#7203](https://github.com/astral-sh/ruff/pull/7203))
-
-GitLab uses fingerprints to identify new, existing, or fixed violations. Previously, Ruff included the violation's position in the fingerprint. Using the location has the downside that changing any code before the violation causes the fingerprint to change, resulting in GitLab reporting one fixed and one new violation even though it is a pre-existing violation.
-
-Ruff now uses a more stable location-agnostic fingerprint to minimize that existing violations incorrectly get marked as fixed and re-reported as new violations.
-
-Expect GitLab to report each pre-existing violation in your project as fixed and a new violation in your Ruff upgrade PR.
-
-## 0.0.283 / 0.284
-
-### The target Python version now defaults to 3.8 instead of 3.10 ([#6397](https://github.com/astral-sh/ruff/pull/6397))
-
-Previously, when a target Python version was not specified, Ruff would use a default of Python 3.10. However, it is safer to default to an _older_ Python version to avoid assuming the availability of new features. We now default to the oldest supported Python version which is currently Python 3.8.
-
-(We still support Python 3.7 but since [it has reached EOL](https://devguide.python.org/versions/#unsupported-versions) we've decided not to make it the default here.)
-
-Note this change was announced in 0.0.283 but not active until 0.0.284.
-
-## 0.0.277
-
-### `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` are now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))
-
-Ruff maintains a list of default exclusions, which now consists of the following patterns:
-
- `.bzr`
- `.direnv`
- `.eggs`
- `.git`
- `.git-rewrite`
- `.hg`
- `.ipynb_checkpoints`
- `.mypy_cache`
- `.nox`
- `.pants.d`
- `.pyenv`
- `.pytest_cache`
- `.pytype`
- `.ruff_cache`
- `.svn`
- `.tox`
- `.venv`
- `.vscode`
- `__pypackages__`
- `_build`
- `buck-out`
- `build`
- `dist`
- `node_modules`
- `venv`
-
-Previously, the `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` directories were not
-excluded by default. This change brings Ruff's default exclusions in line with other tools like
-Black.
-
-## 0.0.276
-
-### The `keep-runtime-typing` setting has been reinstated ([#5470](https://github.com/astral-sh/ruff/pull/5470))
-
-The `keep-runtime-typing` setting has been reinstated with revised semantics. This setting was
-removed in [#4427](https://github.com/astral-sh/ruff/pull/4427), as it was equivalent to ignoring
-the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism.
-
-Taking `UP006` (rewrite `List[int]` to `list[int]`) as an example, the setting now behaves as
-follows:
-
- On Python 3.7 and Python 3.8, setting `keep-runtime-typing = true` will cause Ruff to ignore
-    `UP006` violations, even if `from __future__ import annotations` is present in the file.
-    While such annotations are valid in Python 3.7 and Python 3.8 when combined with
-    `from __future__ import annotations`, they aren't supported by libraries like Pydantic and
-    FastAPI, which rely on runtime type checking.
- On Python 3.9 and above, the setting has no effect, as `list[int]` is a valid type annotation,
-    and libraries like Pydantic and FastAPI support it without issue.
-
-In short: `keep-runtime-typing` can be used to ensure that Ruff doesn't introduce type annotations
-that are not supported at runtime by the current Python version, which are unsupported by libraries
-like Pydantic and FastAPI.
-
-Note that this is not a breaking change, but is included here to complement the previous removal
-of `keep-runtime-typing`.
-
-## 0.0.268
-
-### The `keep-runtime-typing` setting has been removed ([#4427](https://github.com/astral-sh/ruff/pull/4427))
-
-Enabling the `keep-runtime-typing` option, located under the `pyupgrade` section, is equivalent
-to ignoring the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism. As there's no
-need for a dedicated setting to disable these rules, the `keep-runtime-typing` option has been
-removed.
-
-## 0.0.267
-
-### `update-check` is no longer a valid configuration option ([#4313](https://github.com/astral-sh/ruff/pull/4313))
-
-The `update-check` functionality was deprecated in [#2530](https://github.com/astral-sh/ruff/pull/2530),
-in that the behavior itself was removed, and Ruff was changed to warn when that option was enabled.
-
-Now, Ruff will throw an error when `update-check` is provided via a configuration file (e.g.,
-`update-check = false`) or through the command-line, since it has no effect. Users should remove
-this option from their configuration.
-
-## 0.0.265
-
-### `--fix-only` now exits with a zero exit code, unless `--exit-non-zero-on-fix` is specified ([#4146](https://github.com/astral-sh/ruff/pull/4146))
-
-Previously, `--fix-only` would exit with a non-zero exit code if any fixes were applied. This
-behavior was inconsistent with `--fix`, and further, meant that `--exit-non-zero-on-fix` was
-effectively ignored when `--fix-only` was specified.
-
-Now, `--fix-only` will exit with a zero exit code, unless `--exit-non-zero-on-fix` is specified,
-in which case it will exit with a non-zero exit code if any fixes were applied.
-
-## 0.0.260
-
-### Fixes are now represented as a list of edits ([#3709](https://github.com/astral-sh/ruff/pull/3709))
-
-Previously, Ruff represented each fix as a single edit, which prohibited Ruff from automatically
-fixing violations that required multiple edits across a file. As such, Ruff now represents each
-fix as a list of edits.
-
-This primarily affects the JSON API. Ruff's JSON representation used to represent the `fix` field as
-a single edit, like so:
-
-```json
-{
-    "message": "Remove unused import: `sys`",
-    "content": "",
-    "location": {"row": 1, "column": 0},
-    "end_location": {"row": 2, "column": 0}
-}
-```
-
-The updated representation instead includes a list of edits:
-
-```json
-{
-    "message": "Remove unused import: `sys`",
-    "edits": [
-        {
-            "content": "",
-            "location": {"row": 1, "column": 0},
-            "end_location": {"row": 2, "column": 0},
-        }
-    ]
-}
-```
-
-## 0.0.246
-
-### `multiple-statements-on-one-line-def` (`E704`) was removed ([#2773](https://github.com/astral-sh/ruff/pull/2773))
-
-This rule was introduced in v0.0.245. However, it turns out that pycodestyle and Flake8 ignore this
-rule by default, as it is not part of PEP 8. As such, we've removed it from Ruff.
-
-## 0.0.245
-
-### Ruff's public `check` method was removed ([#2709](https://github.com/astral-sh/ruff/pull/2709))
-
-Previously, Ruff exposed a `check` method as a public Rust API. This method was used by few,
-if any clients, and was not well documented or supported. As such, it has been removed, with
-the intention of adding a stable public API in the future.
-
-## 0.0.238
-
-### `select`, `extend-select`, `ignore`, and `extend-ignore` have new semantics ([#2312](https://github.com/astral-sh/ruff/pull/2312))
-
-Previously, the interplay between `select` and its related options could lead to unexpected
-behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore ALL`
-behaved differently. (See [#2312](https://github.com/astral-sh/ruff/pull/2312) for more
-examples.)
-
-When Ruff determines the enabled rule set, it has to reconcile `select` and `ignore` from a variety
-of sources, including the current `pyproject.toml`, any inherited `pyproject.toml` files, and the
-CLI.
-
-The new semantics are such that Ruff uses the "highest-priority" `select` as the basis for the rule
-set, and then applies any `extend-select`, `ignore`, and `extend-ignore` adjustments. CLI options
-are given higher priority than `pyproject.toml` options, and the current `pyproject.toml` file is
-given higher priority than any inherited `pyproject.toml` files.
-
-`extend-select` and `extend-ignore` are no longer given "top priority"; instead, they merely append
-to the `select` and `ignore` lists, as in Flake8.
-
-This change is largely backwards compatible -- most users should experience no change in behavior.
-However, as an example of a breaking change, consider the following:
-
-```toml
-[tool.ruff]
-ignore = ["F401"]
-```
-
-Running `ruff --select F` would previously have enabled all `F` rules, apart from `F401`. Now, it
-will enable all `F` rules, including `F401`, as the command line's `--select` resets the resolution.
-
-### `remove-six-compat` (`UP016`) has been removed ([#2332](https://github.com/astral-sh/ruff/pull/2332))
-
-The `remove-six-compat` rule has been removed. This rule was only useful for one-time Python 2-to-3
-upgrades.
-
-## 0.0.237
-
-### `--explain`, `--clean`, and `--generate-shell-completion` are now subcommands ([#2190](https://github.com/astral-sh/ruff/pull/2190))
-
-`--explain`, `--clean`, and `--generate-shell-completion` are now implemented as subcommands:
-
-```console
-ruff .         # Still works! And will always work.
-ruff check .   # New! Also works.
-
-ruff --explain E402   # Still works.
-ruff rule E402        # New! Also works. (And preferred.)
-
-# Oops! The command has to come first.
-ruff --format json --explain E402   # No longer works.
-ruff --explain E402 --format json   # Still works!
-ruff rule E402   --format json      # Works! (And preferred.)
-```
-
-This change is largely backwards compatible -- most users should experience
-no change in behavior. However, please note the following exceptions:
-
- Subcommands will now fail when invoked with unsupported arguments, instead
-    of silently ignoring them. For example, the following will now fail:
-
-    ```console
-    ruff --clean --respect-gitignore
-    ```
-
-    (the `clean` command doesn't support `--respect-gitignore`.)
-
- The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
-    For example, prior to this release, running `ruff rule` would run `ruff` over a file or
-    directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
-    only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
-    or `generate-shell-completion`.
-
- Scripts that invoke ruff should supply `--` before any positional arguments.
-    (The semantics of `ruff -- <arg>` have not changed.)
-
- `--explain` previously treated `--format grouped` as a synonym for `--format text`.
-    This is no longer supported; instead, use `--format text`.
-
-## 0.0.226
-
-### `misplaced-comparison-constant` (`PLC2201`) was deprecated in favor of `SIM300` ([#1980](https://github.com/astral-sh/ruff/pull/1980))
-
-These two rules contain (nearly) identical logic. To deduplicate the rule set, we've upgraded
-`SIM300` to handle a few more cases, and deprecated `PLC2201` in favor of `SIM300`.
-
-## 0.0.225
-
-### `@functools.cache` rewrites have been moved to a standalone rule (`UP033`) ([#1938](https://github.com/astral-sh/ruff/pull/1938))
-
-Previously, `UP011` handled both `@functools.lru_cache()`-to-`@functools.lru_cache` conversions,
-_and_ `@functools.lru_cache(maxsize=None)`-to-`@functools.cache` conversions. The latter has been
-moved out to its own rule (`UP033`). As such, some `# noqa: UP011` comments may need to be updated
-to reflect the change in rule code.
-
-## 0.0.222
-
-### `--max-complexity` has been removed from the CLI ([#1877](https://github.com/astral-sh/ruff/pull/1877))
-
-The McCabe plugin's `--max-complexity` setting has been removed from the CLI, for consistency with
-the treatment of other, similar settings.
-
-To set the maximum complexity, use the `max-complexity` property in your `pyproject.toml` file,
-like so:
-
-```toml
-[tool.ruff.mccabe]
-max-complexity = 10
-```
-
-## 0.0.181
-
-### Files excluded by `.gitignore` are now ignored ([#1234](https://github.com/astral-sh/ruff/pull/1234))
-
-Ruff will now avoid checking files that are excluded by `.ignore`, `.gitignore`,
-`.git/info/exclude`, and global `gitignore` files. This behavior is powered by the [`ignore`](https://docs.rs/ignore/latest/ignore/struct.WalkBuilder.html#ignore-rules)
-crate, and is applied in addition to Ruff's built-in `exclude` system.
-
-To disable this behavior, set `respect-gitignore = false` in your `pyproject.toml` file.
-
-Note that hidden files (i.e., files and directories prefixed with a `.`) are _not_ ignored by
-default.
-
-## 0.0.178
-
-### Configuration files are now resolved hierarchically ([#1190](https://github.com/astral-sh/ruff/pull/1190))
-
-`pyproject.toml` files are now resolved hierarchically, such that for each Python file, we find
-the first `pyproject.toml` file in its path, and use that to determine its lint settings.
-
-See the [documentation](https://docs.astral.sh/ruff/configuration/#python-file-discovery) for more.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,17 +1,5 @@
 # Contributor Covenant Code of Conduct

- [Our Pledge](#our-pledge)
- [Our Standards](#our-standards)
- [Enforcement Responsibilities](#enforcement-responsibilities)
- [Scope](#scope)
- [Enforcement](#enforcement)
- [Enforcement Guidelines](#enforcement-guidelines)
-    - [1. Correction](#1-correction)
-    - [2. Warning](#2-warning)
-    - [3. Temporary Ban](#3-temporary-ban)
-    - [4. Permanent Ban](#4-permanent-ban)
- [Attribution](#attribution)
-
 ## Our Pledge

 We as members, contributors, and leaders pledge to make participation in our
@@ -29,24 +17,24 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:

- Demonstrating empathy and kindness toward other people
- Being respectful of differing opinions, viewpoints, and experiences
- Giving and gracefully accepting constructive feedback
- Accepting responsibility and apologizing to those affected by our mistakes,
-    and learning from the experience
- Focusing on what is best not just for us as individuals, but for the
-    overall community
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community

 Examples of unacceptable behavior include:

- The use of sexualized language or imagery, and sexual attention or
-    advances of any kind
- Trolling, insulting or derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or email
-    address, without their explicit permission
- Other conduct which could reasonably be considered inappropriate in a
-    professional setting
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting

 ## Enforcement Responsibilities

@@ -71,7 +59,8 @@ representative at an online or offline event.
 ## Enforcement

 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at <hey@astral.sh>.
+reported to the community leaders responsible for enforcement at
+charlie.r.marsh@gmail.com.
 All complaints will be reviewed and investigated promptly and fairly.

 All community leaders are obligated to respect the privacy and security of the
@@ -117,7 +106,7 @@ Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban

 **Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
+standards, including sustained inappropriate behavior,  harassment of an
 individual, or aggression toward or disparagement of classes of individuals.

 **Consequence**: A permanent ban from any sort of public interaction within
@@ -126,12 +115,14 @@ the community.
 ## Attribution

 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available [here](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html).
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).

-For answers to common questions about this code of conduct, see the [FAQ](https://www.contributor-covenant.org/faq).
-Translations are available [here](https://www.contributor-covenant.org/translations).
-
 [homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,26 +2,12 @@

 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.

-> [!NOTE]
->
-> This guide is for Ruff. If you're looking to contribute to ty, please see [the ty contributing
-> guide](https://github.com/astral-sh/ruff/blob/main/crates/ty/CONTRIBUTING.md).
+## The basics

-## The Basics
-
-Ruff welcomes contributions in the form of pull requests.
-
-For small changes (e.g., bug fixes), feel free to submit a PR.
-
-For larger changes (e.g., new lint rules, new functionality, new configuration options), consider
-creating an [**issue**](https://github.com/astral-sh/ruff/issues) outlining your proposed change.
-You can also join us on [Discord](https://discord.com/invite/astral-sh) to discuss your idea with the
-community. We've labeled [beginner-friendly tasks](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
-in the issue tracker, along with [bugs](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
-and [improvements](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)
-that are ready for contributions.
-
-If you have suggestions on how we might improve the contributing documentation, [let us know](https://github.com/astral-sh/ruff/discussions/5693)!
+Ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
+free to submit a PR. For larger changes (e.g., new lint rules, new functionality, new configuration
+options), consider submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
+your proposed change.

 ### Prerequisites

@@ -34,262 +20,85 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```

-You'll need [uv](https://docs.astral.sh/uv/getting-started/installation/) (or `pipx` and `pip`) to
-run Python utility commands.
-
-You can optionally install pre-commit hooks to automatically run the validation checks
-when making a commit:
-
-```shell
-uv tool install pre-commit
-pre-commit install
-```
-
-We recommend [nextest](https://nexte.st/) to run Ruff's test suite (via `cargo nextest run`),
-though it's not strictly necessary:
-
-```shell
-cargo install cargo-nextest --locked
-```
-
-Throughout this guide, any usages of `cargo test` can be replaced with `cargo nextest run`,
-if you choose to install `nextest`.
-
 ### Development

-After cloning the repository, run Ruff locally from the repository root with:
+After cloning the repository, run Ruff locally with:

 ```shell
-cargo run -p ruff -- check /path/to/file.py --no-cache
+cargo run resources/test/fixtures --no-cache
 ```

-Prior to opening a pull request, ensure that your code has been auto-formatted,
-and that it passes both the lint and test validation checks:
+Prior to opening a pull request, ensure that your code has been auto-formatted, and that it passes
+both the lint and test validation checks:

 ```shell
-cargo clippy --workspace --all-targets --all-features -- -D warnings  # Rust linting
-RUFF_UPDATE_SCHEMA=1 cargo test  # Rust testing and updating ruff.schema.json
-uvx pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
+cargo +nightly fmt --all     # Auto-formatting...
+cargo +nightly clippy --all  # Linting...
+cargo +nightly test --all    # Testing...
 ```

-These checks will run on GitHub Actions when you open your pull request, but running them locally
+These checks will run on GitHub Actions when you open your Pull Request, but running them locally
 will save you time and expedite the merge process.

-If you're using VS Code, you can also install the recommended [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) extension to get these checks while editing.
-
-Note that many code changes also require updating the snapshot tests, which is done interactively
-after running `cargo test` like so:
-
-```shell
-cargo insta review
-```
-
-If your pull request relates to a specific lint rule, include the category and rule code in the
-title, as in the following examples:
-
- \[`flake8-bugbear`\] Avoid false positive for usage after `continue` (`B031`)
- \[`flake8-simplify`\] Detect implicit `else` cases in `needless-bool` (`SIM103`)
- \[`pycodestyle`\] Implement `redundant-backslash` (`E502`)
-
-Your pull request will be reviewed by a maintainer, which may involve a few rounds of iteration
+Your Pull Request will be reviewed by a maintainer, which may involve a few rounds of iteration
 prior to merging.

-### Project Structure
-
-Ruff is structured as a monorepo with a [flat crate structure](https://matklad.github.io/2021/08/22/large-rust-workspaces.html),
-such that all crates are contained in a flat `crates` directory.
-
-The vast majority of the code, including all lint rules, lives in the `ruff_linter` crate (located
-at `crates/ruff_linter`). As a contributor, that's the crate that'll be most relevant to you.
-
-At the time of writing, the repository includes the following crates:
-
- `crates/ruff_linter`: library crate containing all lint rules and the core logic for running them.
-    If you're working on a rule, this is the crate for you.
- `crates/ruff_benchmark`: binary crate for running micro-benchmarks.
- `crates/ruff_cache`: library crate for caching lint results.
- `crates/ruff`: binary crate containing Ruff's command-line interface.
- `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g.,
-    `cargo dev generate-all`), see the [`cargo dev`](#cargo-dev) section below.
- `crates/ruff_diagnostics`: library crate for the rule-independent abstractions in the lint
-    diagnostics APIs.
- `crates/ruff_formatter`: library crate for language agnostic code formatting logic based on an
-    intermediate representation. The backend for `ruff_python_formatter`.
- `crates/ruff_index`: library crate inspired by `rustc_index`.
- `crates/ruff_macros`: proc macro crate containing macros used by Ruff.
- `crates/ruff_notebook`: library crate for parsing and manipulating Jupyter notebooks.
- `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities.
- `crates/ruff_python_codegen`: library crate containing utilities for generating Python source code.
- `crates/ruff_python_formatter`: library crate implementing the Python formatter. Emits an
-    intermediate representation for each node, which `ruff_formatter` prints based on the configured
-    line length.
- `crates/ruff_python_semantic`: library crate containing Python-specific semantic analysis logic,
-    including Ruff's semantic model. Used to resolve queries like "What import does this variable
-    refer to?"
- `crates/ruff_python_stdlib`: library crate containing Python-specific standard library data, e.g.
-    the names of all built-in exceptions and which standard library types are immutable.
- `crates/ruff_python_trivia`: library crate containing Python-specific trivia utilities (e.g.,
-    for analyzing indentation, newlines, etc.).
- `crates/ruff_python_parser`: library crate containing the Python parser.
- `crates/ruff_wasm`: library crate for exposing Ruff as a WebAssembly module. Powers the
-    [Ruff Playground](https://play.ruff.rs/).
-
 ### Example: Adding a new lint rule

-At a high level, the steps involved in adding a new lint rule are as follows:
+There are four phases to adding a new lint rule:

-1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention)
-    (e.g., `AssertFalse`, as in, "allow `assert False`").
+1. Define the rule in `src/checks.rs`.
+2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks),
+   `src/check_tokens.rs` (for token-based checks), or `src/check_lines.rs` (for text-based checks).
+3. Add a test fixture.
+4. Update the generated files (documentation and generated code).

-1. Create a file for your rule (e.g., `crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs`).
+To define the rule, open up `src/checks.rs`. You'll need to define both a `CheckCode` and
+`CheckKind`. As an example, you can grep for `E402` and `ModuleImportNotAtTopOfFile`, and follow the
+pattern implemented therein.

-1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
-    `#[derive(ViolationMetadata)]` to see examples.
+To trigger the rule, you'll likely want to augment the logic in `src/check_ast.rs`, which defines
+the Python AST visitor, responsible for iterating over the abstract syntax tree and collecting
+lint-rule violations as it goes. If you need to inspect the AST, you can run `cargo dev print-ast`
+with a Python file. Grep for the `Check::new` invocations to understand how other, similar rules
+are implemented.

-1. In that file, define a function that adds the violation to the diagnostic list as appropriate
-    (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
-    an `ast::StmtAssert` node).
+To add a test fixture, create a file under `resources/test/fixtures`, named to match the `CheckCode`
+you defined earlier (e.g., `E402.py`). This file should contain a variety of violations and
+non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run Ruff locally
+with (e.g.) `cargo run resources/test/fixtures/E402.py --no-cache`. Once you're satisfied with the
+output, codify the behavior as a snapshot test by adding a new `testcase` macro to the `mod tests`
+section of `src/linter.rs`, like so:

-1. Define the logic for invoking the diagnostic in `crates/ruff_linter/src/checkers/ast/analyze` (for
-    AST-based rules), `crates/ruff_linter/src/checkers/tokens.rs` (for token-based rules),
-    `crates/ruff_linter/src/checkers/physical_lines.rs` (for text-based rules),
-    `crates/ruff_linter/src/checkers/filesystem.rs` (for filesystem-based rules), etc. For AST-based rules,
-    you'll likely want to modify `analyze/statement.rs` (if your rule is based on analyzing
-    statements, like imports) or `analyze/expression.rs` (if your rule is based on analyzing
-    expressions, like function calls).
+```rust
+#[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
+...
+```

-1. Map the violation struct to a rule code in `crates/ruff_linter/src/codes.rs` (e.g., `B011`). New rules
-    should be added in `RuleGroup::Preview`.
+Then, run `cargo test`. Your test will fail, but you'll be prompted to follow-up with
+`cargo insta review`. Accept the generated snapshot, then commit the snapshot file alongside the
+rest of your changes.

-1. Add proper [testing](#rule-testing-fixtures-and-snapshots) for your rule.
-
-1. Update the generated files (documentation and generated code).
-
-To trigger the violation, you'll likely want to augment the logic in `crates/ruff_linter/src/checkers/ast.rs`
-to call your new function at the appropriate time and with the appropriate inputs. The `Checker`
-defined therein is a Python AST visitor, which iterates over the AST, building up a semantic model,
-and calling out to lint rule analyzer functions as it goes.
-
-If you need to inspect the AST, you can run `cargo dev print-ast` with a Python file. Grep
-for the `Diagnostic::new` invocations to understand how other, similar rules are implemented.
-
-Once you're satisfied with your code, add tests for your rule
-(see: [rule testing](#rule-testing-fixtures-and-snapshots)), and regenerate the documentation and
-associated assets (like our JSON Schema) with `cargo dev generate-all`.
-
-Finally, submit a pull request, and include the category, rule name, and rule code in the title, as
-in:
-
-> \[`pycodestyle`\] Implement `redundant-backslash` (`E502`)
-
-#### Rule naming convention
-
-Like Clippy, Ruff's rule names should make grammatical and logical sense when read as "allow
-${rule}" or "allow ${rule} items", as in the context of suppression comments.
-
-For example, `AssertFalse` fits this convention: it flags `assert False` statements, and so a
-suppression comment would be framed as "allow `assert False`".
-
-As such, rule names should...
-
- Highlight the pattern that is being linted against, rather than the preferred alternative.
-    For example, `AssertFalse` guards against `assert False` statements.
-
- _Not_ contain instructions on how to fix the violation, which instead belong in the rule
-    documentation and the `fix_title`.
-
- _Not_ contain a redundant prefix, like `Disallow` or `Banned`, which are already implied by the
-    convention.
-
-When re-implementing rules from other linters, we prioritize adhering to this convention over
-preserving the original rule name.
-
-#### Rule testing: fixtures and snapshots
-
-To test rules, Ruff uses snapshots of Ruff's output for a given file (fixture). Generally, there
-will be one file per rule (e.g., `E402.py`), and each file will contain all necessary examples of
-both violations and non-violations. `cargo insta review` will generate a snapshot file containing
-Ruff's output for each fixture, which you can then commit alongside your changes.
-
-Once you've completed the code for the rule itself, you can define tests with the following steps:
-
-1. Add a Python file to `crates/ruff_linter/resources/test/fixtures/[linter]` that contains the code you
-    want to test. The file name should match the rule name (e.g., `E402.py`), and it should include
-    examples of both violations and non-violations.
-
-1. Run Ruff locally against your file and verify the output is as expected. Once you're satisfied
-    with the output (you see the violations you expect, and no others), proceed to the next step.
-    For example, if you're adding a new rule named `E402`, you would run:
-
-    ```shell
-    cargo run -p ruff -- check crates/ruff_linter/resources/test/fixtures/pycodestyle/E402.py --no-cache --preview --select E402
-    ```
-
-    **Note:** Only a subset of rules are enabled by default. When testing a new rule, ensure that
-    you activate it by adding `--select ${rule_code}` to the command.
-
-1. Add the test to the relevant `crates/ruff_linter/src/rules/[linter]/mod.rs` file. If you're contributing
-    a rule to a pre-existing set, you should be able to find a similar example to pattern-match
-    against. If you're adding a new linter, you'll need to create a new `mod.rs` file (see,
-    e.g., `crates/ruff_linter/src/rules/flake8_bugbear/mod.rs`)
-
-1. Run `cargo test`. Your test will fail, but you'll be prompted to follow-up
-    with `cargo insta review`. Run `cargo insta review`, review and accept the generated snapshot,
-    then commit the snapshot file alongside the rest of your changes.
-
-1. Run `cargo test` again to ensure that your test passes.
+Finally, to update the documentation, run `cargo dev generate-rules-table` from the repo root. To
+update the generated prefix map, run `cargo dev generate-check-code-prefix`. Both of these commands
+should be run whenever a new check is added to the codebase.

 ### Example: Adding a new configuration option

-Ruff's user-facing settings live in a few different places.
+Ruff's user-facing settings live in two places: first, the command-line options defined with
+[clap](https://docs.rs/clap/latest/clap/) via the `Cli` struct in `src/main.rs`; and second, the
+`Config` struct defined `src/pyproject.rs`, which is responsible for extracting user-defined
+settings from a `pyproject.toml` file.

-First, the command-line options are defined via the `Args` struct in `crates/ruff/src/args.rs`.
+Ultimately, these two sources of configuration are merged into the `Settings` struct defined
+in `src/settings.rs`, which is then threaded through the codebase.

-Second, the `pyproject.toml` options are defined in `crates/ruff_workspace/src/options.rs` (via the
-`Options` struct), `crates/ruff_workspace/src/configuration.rs` (via the `Configuration` struct),
-and `crates/ruff_workspace/src/settings.rs` (via the `Settings` struct), which then includes
-the `LinterSettings` struct as a field.
+To add a new configuration option, you'll likely want to _both_ add a CLI option to `src/main.rs`
+_and_ a `pyproject.toml` parameter to `src/pyproject.rs`. If you want to pattern-match against an
+existing example, grep for `dummy_variable_rgx`, which defines a regular expression to match against
+acceptable unused variables (e.g., `_`).

-These represent, respectively: the schema used to parse the `pyproject.toml` file; an internal,
-intermediate representation; and the final, internal representation used to power Ruff.
-
-To add a new configuration option, you'll likely want to modify these latter few files (along with
-`args.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
-`dummy_variable_rgx`, which defines a regular expression to match against acceptable unused
-variables (e.g., `_`).
-
-Note that plugin-specific configuration options are defined in their own modules (e.g.,
-`Settings` in `crates/ruff_linter/src/flake8_unused_arguments/settings.rs` coupled with
-`Flake8UnusedArgumentsOptions` in `crates/ruff_workspace/src/options.rs`).
-
-Finally, regenerate the documentation and generated code with `cargo dev generate-all`.
-
-## MkDocs
-
-To preview any changes to the documentation locally:
-
-1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).
-
-1. Generate the MkDocs site with:
-
-    ```shell
-    uv run --no-project --isolated --with-requirements docs/requirements.txt scripts/generate_mkdocs.py
-    ```
-
-1. Run the development server with:
-
-    ```shell
-    # For contributors.
-    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.public.yml
-
-    # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
-    uvx --with-requirements docs/requirements-insiders.txt -- mkdocs serve -f mkdocs.insiders.yml
-    ```
-
-The documentation should then be available locally at
-[http://127.0.0.1:8000/ruff/](http://127.0.0.1:8000/ruff/).
-
-## Release Process
+## Release process

 As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub
 Actions, which automatically generates the appropriate wheels across architectures and publishes
@@ -297,625 +106,3 @@ them to [PyPI](https://pypi.org/project/ruff/).

 Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
-
-### Creating a new release
-
-1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
-
-1. Run `./scripts/release.sh`; this command will:
-
-    - Generate a temporary virtual environment with `rooster`
-    - Generate a changelog entry in `CHANGELOG.md`
-    - Update versions in `pyproject.toml` and `Cargo.toml`
-    - Update references to versions in the `README.md` and documentation
-    - Display contributors for the release
-
-1. The changelog should then be editorialized for consistency
-
-    - Often labels will be missing from pull requests they will need to be manually organized into the proper section
-    - Changes should be edited to be user-facing descriptions, avoiding internal details
-
-1. Highlight any breaking changes in `BREAKING_CHANGES.md`
-
-1. Run `cargo check`. This should update the lock file with new versions.
-
-1. Create a pull request with the changelog and version updates
-
-1. Merge the PR
-
-1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yml) with:
-
-    - The new version number (without starting `v`)
-
-1. The release workflow will do the following:
-
-    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
-        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
-        make sure you're [re-running all the failed
-        jobs](https://docs.github.com/en/actions/managing-workflow-runs/re-running-workflows-and-jobs#re-running-failed-jobs-in-a-workflow) and not just a single failed job.
-    1. Upload to PyPI.
-    1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
-        after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/astral-sh/ruff/issues/4468)).
-    1. Attach artifacts to draft GitHub release
-    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
-        downstream jobs manually if needed.
-
-1. Verify the GitHub release:
-
-    1. The Changelog should match the content of `CHANGELOG.md`
-    1. Append the contributors from the `scripts/release.sh` script
-
-1. If needed, [update the schemastore](https://github.com/astral-sh/ruff/blob/main/scripts/update_schemastore.py).
-
-    1. One can determine if an update is needed when
-        `git diff old-version-tag new-version-tag -- ruff.schema.json` returns a non-empty diff.
-    1. Once run successfully, you should follow the link in the output to create a PR.
-
-1. If needed, update the [`ruff-lsp`](https://github.com/astral-sh/ruff-lsp) and
-    [`ruff-vscode`](https://github.com/astral-sh/ruff-vscode) repositories and follow
-    the release instructions in those repositories. `ruff-lsp` should always be updated
-    before `ruff-vscode`.
-
-    This step is generally not required for a patch release, but should always be done
-    for a minor release.
-
-## Ecosystem CI
-
-GitHub Actions will run your changes against a number of real-world projects from GitHub and
-report on any linter or formatter differences. You can also run those checks locally via:
-
-```shell
-uvx --from ./python/ruff-ecosystem ruff-ecosystem check ruff "./target/debug/ruff"
-uvx --from ./python/ruff-ecosystem ruff-ecosystem format ruff "./target/debug/ruff"
-```
-
-See the [ruff-ecosystem package](https://github.com/astral-sh/ruff/tree/main/python/ruff-ecosystem) for more details.
-
-## Upgrading Rust
-
-1. Change the `channel` in `./rust-toolchain.toml` to the new Rust version (`<latest>`)
-1. Change the `rust-version` in the `./Cargo.toml` to `<latest> - 2` (e.g. 1.84 if the latest is 1.86)
-1. Run `cargo clippy --fix --allow-dirty --allow-staged` to fix new clippy warnings
-1. Create and merge the PR
-1. Bump the Rust version in Ruff's conda forge recipe. See [this PR](https://github.com/conda-forge/ruff-feedstock/pull/266) for an example.
-1. Enjoy the new Rust version!
-
-## Benchmarking and Profiling
-
-We have several ways of benchmarking and profiling Ruff:
-
- Our main performance benchmark comparing Ruff with other tools on the CPython codebase
- Microbenchmarks which run the linter or the formatter on individual files. These run on pull requests.
- Profiling the linter on either the microbenchmarks or entire projects
-
-> **Note**
-> When running benchmarks, ensure that your CPU is otherwise idle (e.g., close any background
-> applications, like web browsers). You may also want to switch your CPU to a "performance"
-> mode, if it exists, especially when benchmarking short-lived processes.
-
-### CPython Benchmark
-
-First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
-which makes it a good target for benchmarking.
-
-```shell
-git clone --branch 3.10 https://github.com/python/cpython.git crates/ruff_linter/resources/test/cpython
-```
-
-Install `hyperfine`:
-
-```shell
-cargo install hyperfine
-```
-
-To benchmark the release build:
-
-```shell
-cargo build --release --bin ruff && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ -e"
-
-Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
-  Time (mean ± σ):     293.8 ms ±   3.2 ms    [User: 2384.6 ms, System: 90.3 ms]
-  Range (min … max):   289.9 ms … 301.6 ms    10 runs
-
-Benchmark 2: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/
-  Time (mean ± σ):      48.0 ms ±   3.1 ms    [User: 65.2 ms, System: 124.7 ms]
-  Range (min … max):    45.0 ms …  66.7 ms    62 runs
-
-Summary
-  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/' ran
-    6.12 ± 0.41 times faster than './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache'
-```
-
-To benchmark against the ecosystem's existing tools:
-
-```shell
-hyperfine --ignore-failure --warmup 5 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
-  "pyflakes crates/ruff_linter/resources/test/cpython" \
-  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
-  "pycodestyle crates/ruff_linter/resources/test/cpython" \
-  "flake8 crates/ruff_linter/resources/test/cpython"
-
-Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
-  Time (mean ± σ):     294.3 ms ±   3.3 ms    [User: 2467.5 ms, System: 89.6 ms]
-  Range (min … max):   291.1 ms … 302.8 ms    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 2: pyflakes crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     15.786 s ±  0.143 s    [User: 15.560 s, System: 0.214 s]
-  Range (min … max):   15.640 s … 16.157 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 3: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
-  Time (mean ± σ):      6.175 s ±  0.169 s    [User: 54.102 s, System: 1.057 s]
-  Range (min … max):    5.950 s …  6.391 s    10 runs
-
-Benchmark 4: pycodestyle crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     46.921 s ±  0.508 s    [User: 46.699 s, System: 0.202 s]
-  Range (min … max):   46.171 s … 47.863 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 5: flake8 crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     12.260 s ±  0.321 s    [User: 102.934 s, System: 1.230 s]
-  Range (min … max):   11.848 s … 12.933 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Summary
-  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache' ran
-   20.98 ± 0.62 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
-   41.66 ± 1.18 times faster than 'flake8 crates/ruff_linter/resources/test/cpython'
-   53.64 ± 0.77 times faster than 'pyflakes crates/ruff_linter/resources/test/cpython'
-  159.43 ± 2.48 times faster than 'pycodestyle crates/ruff_linter/resources/test/cpython'
-```
-
-To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:
-
-```shell
-cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
-```
-
-You can run `uv venv --project ./scripts/benchmarks`, activate the venv and then run `uv sync --project ./scripts/benchmarks` to create a working environment for the
-above. All reported benchmarks were computed using the versions specified by
-`./scripts/benchmarks/pyproject.toml` on Python 3.11.
-
-To benchmark Pylint, remove the following files from the CPython repository:
-
-```shell
-rm Lib/test/bad_coding.py \
-  Lib/test/bad_coding2.py \
-  Lib/test/bad_getattr.py \
-  Lib/test/bad_getattr2.py \
-  Lib/test/bad_getattr3.py \
-  Lib/test/badcert.pem \
-  Lib/test/badkey.pem \
-  Lib/test/badsyntax_3131.py \
-  Lib/test/badsyntax_future10.py \
-  Lib/test/badsyntax_future3.py \
-  Lib/test/badsyntax_future4.py \
-  Lib/test/badsyntax_future5.py \
-  Lib/test/badsyntax_future6.py \
-  Lib/test/badsyntax_future7.py \
-  Lib/test/badsyntax_future8.py \
-  Lib/test/badsyntax_future9.py \
-  Lib/test/badsyntax_pep3120.py \
-  Lib/test/test_asyncio/test_runners.py \
-  Lib/test/test_copy.py \
-  Lib/test/test_inspect.py \
-  Lib/test/test_typing.py
-```
-
-Then, from `crates/ruff_linter/resources/test/cpython`, run: `time pylint -j 0 -E $(git ls-files '*.py')`. This
-will execute Pylint with maximum parallelism and only report errors.
-
-To benchmark Pyupgrade, run the following from `crates/ruff_linter/resources/test/cpython`:
-
-```shell
-hyperfine --ignore-failure --warmup 5 --prepare "git reset --hard HEAD" \
-  "find . -type f -name \"*.py\" | xargs -P 0 pyupgrade --py311-plus"
-
-Benchmark 1: find . -type f -name "*.py" | xargs -P 0 pyupgrade --py311-plus
-  Time (mean ± σ):     30.119 s ±  0.195 s    [User: 28.638 s, System: 0.390 s]
-  Range (min … max):   29.813 s … 30.356 s    10 runs
-```
-
-### Microbenchmarks
-
-The `ruff_benchmark` crate benchmarks the linter and the formatter on individual files.
-
-You can run the benchmarks with
-
-```shell
-cargo benchmark
-```
-
-`cargo benchmark` is an alias for `cargo bench -p ruff_benchmark --bench linter --bench formatter --`
-
-#### Benchmark-driven Development
-
-Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
-`--save-baseline=<name>` to store an initial baseline benchmark (e.g., on `main`) and then use
-`--benchmark=<name>` to compare against that benchmark. Criterion will print a message telling you
-if the benchmark improved/regressed compared to that baseline.
-
-```shell
-# Run once on your "baseline" code
-cargo bench -p ruff_benchmark -- --save-baseline=main
-
-# Then iterate with
-cargo bench -p ruff_benchmark -- --baseline=main
-```
-
-#### PR Summary
-
-You can use `--save-baseline` and `critcmp` to get a pretty comparison between two recordings.
-This is useful to illustrate the improvements of a PR.
-
-```shell
-# On main
-cargo bench -p ruff_benchmark -- --save-baseline=main
-
-# After applying your changes
-cargo bench -p ruff_benchmark -- --save-baseline=pr
-
-critcmp main pr
-```
-
-You must install [`critcmp`](https://github.com/BurntSushi/critcmp) for the comparison.
-
-```bash
-cargo install critcmp
-```
-
-#### Tips
-
- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo bench -p ruff_benchmark lexer`
-    to only run the lexer benchmarks.
- Use `cargo bench -p ruff_benchmark -- --quiet` for a more cleaned up output (without statistical relevance)
- Use `cargo bench -p ruff_benchmark -- --quick` to get faster results (more prone to noise)
-
-### Profiling Projects
-
-You can either use the microbenchmarks from above or a project directory for benchmarking. There
-are a lot of profiling tools out there,
-[The Rust Performance Book](https://nnethercote.github.io/perf-book/profiling.html) lists some
-examples.
-
-#### Linux
-
-Install `perf` and build `ruff_benchmark` with the `profiling` profile and then run it with perf
-
-```shell
-cargo bench -p ruff_benchmark --no-run --profile=profiling && perf record --call-graph dwarf -F 9999 cargo bench -p ruff_benchmark --profile=profiling -- --profile-time=1
-```
-
-You can also use the `ruff_dev` launcher to run `ruff check` multiple times on a repository to
-gather enough samples for a good flamegraph (change the 999, the sample rate, and the 30, the number
-of checks, to your liking)
-
-```shell
-cargo build --bin ruff_dev --profile=profiling
-perf record -g -F 999 target/profiling/ruff_dev repeat --repeat 30 --exit-zero --no-cache path/to/cpython > /dev/null
-```
-
-Then convert the recorded profile
-
-```shell
-perf script -F +pid > /tmp/test.perf
-```
-
-You can now view the converted file with [firefox profiler](https://profiler.firefox.com/). To learn more about Firefox profiler, read the [Firefox profiler profiling-guide](https://profiler.firefox.com/docs/#/./guide-perf-profiling).
-
-An alternative is to convert the perf data to `flamegraph.svg` using
-[flamegraph](https://github.com/flamegraph-rs/flamegraph) (`cargo install flamegraph`):
-
-```shell
-flamegraph --perfdata perf.data --no-inline
-```
-
-#### Mac
-
-Install [`cargo-instruments`](https://crates.io/crates/cargo-instruments):
-
-```shell
-cargo install cargo-instruments
-```
-
-Then run the profiler with
-
-```shell
-cargo instruments -t time --bench linter --profile profiling -p ruff_benchmark -- --profile-time=1
-```
-
- `-t`: Specifies what to profile. Useful options are `time` to profile the wall time and `alloc`
-    for profiling the allocations.
- You may want to pass an additional filter to run a single test file
-
-Otherwise, follow the instructions from the linux section.
-
-## `cargo dev`
-
-`cargo dev` is a shortcut for `cargo run --package ruff_dev --bin ruff_dev`. You can run some useful
-utils with it:
-
- `cargo dev print-ast <file>`: Print the AST of a python file using Ruff's
-    [Python parser](https://github.com/astral-sh/ruff/tree/main/crates/ruff_python_parser).
-    For `if True: pass # comment`, you can see the syntax tree, the byte offsets for start and
-    stop of each node and also how the `:` token, the comment and whitespace are not represented
-    anymore:
-
-```text
-[
-    If(
-        StmtIf {
-            range: 0..13,
-            test: Constant(
-                ExprConstant {
-                    range: 3..7,
-                    value: Bool(
-                        true,
-                    ),
-                    kind: None,
-                },
-            ),
-            body: [
-                Pass(
-                    StmtPass {
-                        range: 9..13,
-                    },
-                ),
-            ],
-            orelse: [],
-        },
-    ),
-]
-```
-
- `cargo dev print-tokens <file>`: Print the tokens that the AST is built upon. Again for
-    `if True: pass # comment`:
-
-```text
-0 If 2
-3 True 7
-7 Colon 8
-9 Pass 13
-14 Comment(
-    "# comment",
-) 23
-23 Newline 24
-```
-
- `cargo dev print-cst <file>`: Print the CST of a Python file using
-    [LibCST](https://github.com/Instagram/LibCST), which is used in addition to the RustPython parser
-    in Ruff. For example, for `if True: pass # comment`, everything, including the whitespace, is represented:
-
-```text
-Module {
-    body: [
-        Compound(
-            If(
-                If {
-                    test: Name(
-                        Name {
-                            value: "True",
-                            lpar: [],
-                            rpar: [],
-                        },
-                    ),
-                    body: SimpleStatementSuite(
-                        SimpleStatementSuite {
-                            body: [
-                                Pass(
-                                    Pass {
-                                        semicolon: None,
-                                    },
-                                ),
-                            ],
-                            leading_whitespace: SimpleWhitespace(
-                                " ",
-                            ),
-                            trailing_whitespace: TrailingWhitespace {
-                                whitespace: SimpleWhitespace(
-                                    " ",
-                                ),
-                                comment: Some(
-                                    Comment(
-                                        "# comment",
-                                    ),
-                                ),
-                                newline: Newline(
-                                    None,
-                                    Real,
-                                ),
-                            },
-                        },
-                    ),
-                    orelse: None,
-                    leading_lines: [],
-                    whitespace_before_test: SimpleWhitespace(
-                        " ",
-                    ),
-                    whitespace_after_test: SimpleWhitespace(
-                        "",
-                    ),
-                    is_elif: false,
-                },
-            ),
-        ),
-    ],
-    header: [],
-    footer: [],
-    default_indent: "    ",
-    default_newline: "\n",
-    has_trailing_newline: true,
-    encoding: "utf-8",
-}
-```
-
- `cargo dev generate-all`: Update `ruff.schema.json`, `docs/configuration.md` and `docs/rules`.
-    You can also set `RUFF_UPDATE_SCHEMA=1` to update `ruff.schema.json` during `cargo test`.
- `cargo dev generate-cli-help`, `cargo dev generate-docs` and `cargo dev generate-json-schema`:
-    Update just `docs/configuration.md`, `docs/rules` and `ruff.schema.json` respectively.
- `cargo dev generate-options`: Generate a markdown-compatible table of all `pyproject.toml`
-    options. Used for <https://docs.astral.sh/ruff/settings/>.
- `cargo dev generate-rules-table`: Generate a markdown-compatible table of all rules. Used for <https://docs.astral.sh/ruff/rules/>.
- `cargo dev round-trip <python file or jupyter notebook>`: Read a Python file or Jupyter Notebook,
-    parse it, serialize the parsed representation and write it back. Used to check how good our
-    representation is so that fixes don't rewrite irrelevant parts of a file.
- `cargo dev format_dev`: See ruff_python_formatter README.md
-
-## Subsystems
-
-### Compilation Pipeline
-
-If we view Ruff as a compiler, in which the inputs are paths to Python files and the outputs are
-diagnostics, then our current compilation pipeline proceeds as follows:
-
-1. **File discovery**: Given paths like `foo/`, locate all Python files in any specified subdirectories, taking into account our hierarchical settings system and any `exclude` options.
-
-1. **Package resolution**: Determine the "package root" for every file by traversing over its parent directories and looking for `__init__.py` files.
-
-1. **Cache initialization**: For every "package root", initialize an empty cache.
-
-1. **Analysis**: For every file, in parallel:
-
-    1. **Cache read**: If the file is cached (i.e., its modification timestamp hasn't changed since it was last analyzed), short-circuit, and return the cached diagnostics.
-
-    1. **Tokenization**: Run the lexer over the file to generate a token stream.
-
-    1. **Indexing**: Extract metadata from the token stream, such as: comment ranges, `# noqa` locations, `# isort: off` locations, "doc lines", etc.
-
-    1. **Token-based rule evaluation**: Run any lint rules that are based on the contents of the token stream (e.g., commented-out code).
-
-    1. **Filesystem-based rule evaluation**: Run any lint rules that are based on the contents of the filesystem (e.g., lack of `__init__.py` file in a package).
-
-    1. **Logical line-based rule evaluation**: Run any lint rules that are based on logical lines (e.g., stylistic rules).
-
-    1. **Parsing**: Run the parser over the token stream to produce an AST. (This consumes the token stream, so anything that relies on the token stream needs to happen before parsing.)
-
-    1. **AST-based rule evaluation**: Run any lint rules that are based on the AST. This includes the vast majority of lint rules. As part of this step, we also build the semantic model for the current file as we traverse over the AST. Some lint rules are evaluated eagerly, as we iterate over the AST, while others are evaluated in a deferred manner (e.g., unused imports, since we can't determine whether an import is unused until we've finished analyzing the entire file), after we've finished the initial traversal.
-
-    1. **Import-based rule evaluation**: Run any lint rules that are based on the module's imports (e.g., import sorting). These could, in theory, be included in the AST-based rule evaluation phase — they're just separated for simplicity.
-
-    1. **Physical line-based rule evaluation**: Run any lint rules that are based on physical lines (e.g., line-length).
-
-    1. **Suppression enforcement**: Remove any violations that are suppressed via `# noqa` directives or `per-file-ignores`.
-
-    1. **Cache write**: Write the generated diagnostics to the package cache using the file as a key.
-
-1. **Reporting**: Print diagnostics in the specified format (text, JSON, etc.), to the specified output channel (stdout, a file, etc.).
-
-### Import Categorization
-
-To understand Ruff's import categorization system, we first need to define two concepts:
-
- "Project root": The directory containing the `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file,
-    discovered by identifying the "closest" such directory for each Python file. (If you're running
-    via `ruff --config /path/to/pyproject.toml`, then the current working directory is used as the
-    "project root".)
- "Package root": The top-most directory defining the Python package that includes a given Python
-    file. To find the package root for a given Python file, traverse up its parent directories until
-    you reach a parent directory that doesn't contain an `__init__.py` file (and isn't in a subtree
-    marked as a [namespace package](https://docs.astral.sh/ruff/settings/#namespace-packages)); take the directory
-    just before that, i.e., the first directory in the package.
-
-For example, given:
-
-```text
-my_project
-├── pyproject.toml
-└── src
-    └── foo
-        ├── __init__.py
-        └── bar
-            ├── __init__.py
-            └── baz.py
-```
-
-Then when analyzing `baz.py`, the project root would be the top-level directory (`./my_project`),
-and the package root would be `./my_project/src/foo`.
-
-#### Project root
-
-The project root does not have a significant impact beyond that all relative paths within the loaded
-configuration file are resolved relative to the project root.
-
-For example, to indicate that `bar` above is a namespace package (it isn't, but let's run with it),
-the `pyproject.toml` would list `namespace-packages = ["./src/bar"]`, which would resolve
-to `my_project/src/bar`.
-
-The same logic applies when providing a configuration file via `--config`. In that case, the
-_current working directory_ is used as the project root, and so all paths in that configuration file
-are resolved relative to the current working directory. (As a general rule, we want to avoid relying
-on the current working directory as much as possible, to ensure that Ruff exhibits the same behavior
-regardless of where and how you invoke it — but that's hard to avoid in this case.)
-
-Additionally, if a `pyproject.toml` file _extends_ another configuration file, Ruff will still use
-the directory containing that `pyproject.toml` file as the project root. For example, if
-`./my_project/pyproject.toml` contains:
-
-```toml
-[tool.ruff]
-extend = "/path/to/pyproject.toml"
-```
-
-Then Ruff will use `./my_project` as the project root, even though the configuration file extends
-`/path/to/pyproject.toml`. As such, if the configuration file at `/path/to/pyproject.toml` contains
-any relative paths, they will be resolved relative to `./my_project`.
-
-If a project uses nested configuration files, then Ruff would detect multiple project roots, one for
-each configuration file.
-
-#### Package root
-
-The package root is used to determine a file's "module path". Consider, again, `baz.py`. In that
-case, `./my_project/src/foo` was identified as the package root, so the module path for `baz.py`
-would resolve to `foo.bar.baz` — as computed by taking the relative path from the package root
-(inclusive of the root itself). The module path can be thought of as "the path you would use to
-import the module" (e.g., `import foo.bar.baz`).
-
-The package root and module path are used to, e.g., convert relative to absolute imports, and for
-import categorization, as described below.
-
-#### Import categorization
-
-When sorting and formatting import blocks, Ruff categorizes every import into one of five
-categories:
-
-1. **"Future"**: the import is a `__future__` import. That's easy: just look at the name of the
-    imported module!
-1. **"Standard library"**: the import comes from the Python standard library (e.g., `import os`).
-    This is easy too: we include a list of all known standard library modules in Ruff itself, so it's
-    a simple lookup.
-1. **"Local folder"**: the import is a relative import (e.g., `from .foo import bar`). This is easy
-    too: just check if the import includes a `level` (i.e., a dot-prefix).
-1. **"First party"**: the import is part of the current project. (More on this below.)
-1. **"Third party"**: everything else.
-
-The real challenge lies in determining whether an import is first-party — everything else is either
-trivial, or (as in the case of third-party) merely defined as "not first-party".
-
-There are three ways in which an import can be categorized as "first-party":
-
-1. **Explicit settings**: the import is marked as such via the `known-first-party` setting. (This
-    should generally be seen as an escape hatch.)
-1. **Same-package**: the imported module is in the same package as the current file. This gets back
-    to the importance of the "package root" and the file's "module path". Imagine that we're
-    analyzing `baz.py` above. If `baz.py` contains any imports that appear to come from the `foo`
-    package (e.g., `from foo import bar` or `import foo.bar`), they'll be classified as first-party
-    automatically. This check is as simple as comparing the first segment of the current file's
-    module path to the first segment of the import.
-1. **Source roots**: Ruff supports a [`src`](https://docs.astral.sh/ruff/settings/#src) setting, which
-    sets the directories to scan when identifying first-party imports. The algorithm is
-    straightforward: given an import, like `import foo`, iterate over the directories enumerated in
-    the `src` setting and, for each directory, check for the existence of a subdirectory `foo` or a
-    file `foo.py`.
-
-By default, `src` is set to the project root, along with `"src"` subdirectory in the project root.
-This ensures that Ruff supports both flat and "src" layouts out of the box.
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,258 +1,76 @@
 [workspace]
-members = ["crates/*"]
-resolver = "2"
+members = [
+  "flake8_to_ruff",
+  "ruff_dev",
+]

-[workspace.package]
-# Please update rustfmt.toml when bumping the Rust edition
-edition = "2024"
-rust-version = "1.85"
-homepage = "https://docs.astral.sh/ruff"
-documentation = "https://docs.astral.sh/ruff"
-repository = "https://github.com/astral-sh/ruff"
-authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
-license = "MIT"
+[package]
+name = "ruff"
+version = "0.0.108"
+edition = "2021"

-[workspace.dependencies]
-ruff = { path = "crates/ruff" }
-ruff_annotate_snippets = { path = "crates/ruff_annotate_snippets" }
-ruff_cache = { path = "crates/ruff_cache" }
-ruff_db = { path = "crates/ruff_db", default-features = false }
-ruff_diagnostics = { path = "crates/ruff_diagnostics" }
-ruff_formatter = { path = "crates/ruff_formatter" }
-ruff_graph = { path = "crates/ruff_graph" }
-ruff_index = { path = "crates/ruff_index" }
-ruff_linter = { path = "crates/ruff_linter" }
-ruff_macros = { path = "crates/ruff_macros" }
-ruff_notebook = { path = "crates/ruff_notebook" }
-ruff_options_metadata = { path = "crates/ruff_options_metadata" }
-ruff_python_ast = { path = "crates/ruff_python_ast" }
-ruff_python_codegen = { path = "crates/ruff_python_codegen" }
-ruff_python_formatter = { path = "crates/ruff_python_formatter" }
-ruff_python_index = { path = "crates/ruff_python_index" }
-ruff_python_literal = { path = "crates/ruff_python_literal" }
-ruff_python_parser = { path = "crates/ruff_python_parser" }
-ruff_python_semantic = { path = "crates/ruff_python_semantic" }
-ruff_python_stdlib = { path = "crates/ruff_python_stdlib" }
-ruff_python_trivia = { path = "crates/ruff_python_trivia" }
-ruff_server = { path = "crates/ruff_server" }
-ruff_source_file = { path = "crates/ruff_source_file" }
-ruff_text_size = { path = "crates/ruff_text_size" }
-ruff_workspace = { path = "crates/ruff_workspace" }
+[lib]
+name = "ruff"

-ty = { path = "crates/ty" }
-ty_ide = { path = "crates/ty_ide" }
-ty_project = { path = "crates/ty_project", default-features = false }
-ty_python_semantic = { path = "crates/ty_python_semantic" }
-ty_server = { path = "crates/ty_server" }
-ty_test = { path = "crates/ty_test" }
-ty_vendored = { path = "crates/ty_vendored" }
-
-aho-corasick = { version = "1.1.3" }
-anstream = { version = "0.6.18" }
-anstyle = { version = "1.0.10" }
-anyhow = { version = "1.0.80" }
-assert_fs = { version = "1.1.0" }
-argfile = { version = "0.2.0" }
-bincode = { version = "2.0.0" }
-bitflags = { version = "2.5.0" }
-bstr = { version = "1.9.1" }
-cachedir = { version = "0.3.1" }
-camino = { version = "1.1.7" }
-clap = { version = "4.5.3", features = ["derive"] }
-clap_complete_command = { version = "0.6.0" }
-clearscreen = { version = "4.0.0" }
-codspeed-criterion-compat = { version = "2.6.0", default-features = false }
-colored = { version = "3.0.0" }
-console_error_panic_hook = { version = "0.1.7" }
-console_log = { version = "1.0.0" }
-countme = { version = "3.0.1" }
-compact_str = "0.9.0"
-criterion = { version = "0.6.0", default-features = false }
-crossbeam = { version = "0.8.4" }
-dashmap = { version = "6.0.1" }
-dir-test = { version = "0.4.0" }
-dunce = { version = "1.0.5" }
-drop_bomb = { version = "0.1.5" }
-env_logger = { version = "0.11.0" }
-etcetera = { version = "0.10.0" }
-fern = { version = "0.7.0" }
-filetime = { version = "0.2.23" }
-getrandom = { version = "0.3.1" }
-glob = { version = "0.3.1" }
-globset = { version = "0.4.14" }
-globwalk = { version = "0.9.1" }
-hashbrown = { version = "0.15.0", default-features = false, features = [
-    "raw-entry",
-    "equivalent",
-    "inline-more",
-] }
-heck = "0.5.0"
-ignore = { version = "0.4.22" }
-imara-diff = { version = "0.1.5" }
-imperative = { version = "1.0.4" }
-indexmap = { version = "2.6.0" }
-indicatif = { version = "0.17.8" }
-indoc = { version = "2.0.4" }
-insta = { version = "1.35.1" }
-insta-cmd = { version = "0.6.0" }
-is-macro = { version = "0.3.5" }
-is-wsl = { version = "0.4.0" }
-itertools = { version = "0.14.0" }
-jiff = { version = "0.2.0" }
-js-sys = { version = "0.3.69" }
-jod-thread = { version = "1.0.0" }
-libc = { version = "0.2.153" }
-libcst = { version = "1.1.0", default-features = false }
+[dependencies]
+anyhow = { version = "1.0.66" }
+bincode = { version = "1.3.3" }
+chrono = { version = "0.4.21" }
+clap = { version = "4.0.1", features = ["derive"] }
+colored = { version = "2.0.0" }
+common-path = { version = "1.0.0" }
+dirs = { version = "4.0.0" }
+fern = { version = "0.6.1" }
+filetime = { version = "0.2.17" }
+glob = { version = "0.3.0" }
+itertools = { version = "0.10.5" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "a13ec97dd4eb925bde4d426c6e422582793b260c" }
 log = { version = "0.4.17" }
-lsp-server = { version = "0.7.6" }
-lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = [
-    "proposed",
-] }
-matchit = { version = "0.8.1" }
-memchr = { version = "2.7.1" }
-mimalloc = { version = "0.1.39" }
-natord = { version = "1.0.9" }
-notify = { version = "8.0.0" }
-ordermap = { version = "0.5.0" }
-path-absolutize = { version = "3.1.1" }
-path-slash = { version = "0.2.1" }
-pathdiff = { version = "0.2.1" }
-pep440_rs = { version = "0.7.1" }
-pretty_assertions = "1.3.0"
-proc-macro2 = { version = "1.0.79" }
-pyproject-toml = { version = "0.13.4" }
-quick-junit = { version = "0.5.0" }
-quote = { version = "1.0.23" }
-rand = { version = "0.9.0" }
-rayon = { version = "1.10.0" }
-regex = { version = "1.10.2" }
-rustc-hash = { version = "2.0.0" }
-rustc-stable-hash = { version = "0.1.2" }
-# When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/carljm/salsa.git", rev = "0f6d406f6c309964279baef71588746b8c67b4a3" }
-schemars = { version = "0.8.16" }
-seahash = { version = "4.1.0" }
-serde = { version = "1.0.197", features = ["derive"] }
-serde-wasm-bindgen = { version = "0.6.4" }
-serde_json = { version = "1.0.113" }
-serde_test = { version = "1.0.152" }
-serde_with = { version = "3.6.0", default-features = false, features = [
-    "macros",
-] }
-shellexpand = { version = "3.0.0" }
-similar = { version = "2.4.0", features = ["inline"] }
-smallvec = { version = "1.13.2" }
-snapbox = { version = "0.6.0", features = [
-    "diff",
-    "term-svg",
-    "cmd",
-    "examples",
-] }
-static_assertions = "1.1.0"
-strum = { version = "0.27.0", features = ["strum_macros"] }
-strum_macros = { version = "0.27.0" }
-syn = { version = "2.0.55" }
-tempfile = { version = "3.9.0" }
-test-case = { version = "3.3.1" }
-thiserror = { version = "2.0.0" }
-tikv-jemallocator = { version = "0.6.0" }
-toml = { version = "0.8.11" }
-tracing = { version = "0.1.40" }
-tracing-flame = { version = "0.2.0" }
-tracing-indicatif = { version = "0.3.6" }
-tracing-log = { version = "0.2.0" }
-tracing-subscriber = { version = "0.3.18", default-features = false, features = [
-    "env-filter",
-    "fmt",
-    "ansi",
-    "smallvec"
-] }
-tryfn = { version = "0.2.1" }
-typed-arena = { version = "2.0.2" }
-unic-ucd-category = { version = "0.9" }
-unicode-ident = { version = "1.0.12" }
-unicode-width = { version = "0.2.0" }
-unicode_names2 = { version = "1.2.2" }
-unicode-normalization = { version = "0.1.23" }
-url = { version = "2.5.0" }
-uuid = { version = "1.6.1", features = [
-    "v4",
-    "fast-rng",
-    "macro-diagnostics",
-] }
+notify = { version = "4.0.17" }
+num-bigint = { version = "0.4.3" }
+once_cell = { version = "1.16.0" }
+operational-transform = "0.6.1"
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
+rayon = { version = "1.5.3" }
+regex = { version = "1.6.0" }
+ropey = { version = "1.5.0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+serde = { version = "1.0.147", features = ["derive"] }
+serde_json = { version = "1.0.87" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }
+textwrap = { version = "0.16.0" }
+titlecase = { version = "2.2.1" }
+toml = { version = "0.5.9" }
+update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
-wasm-bindgen = { version = "0.2.92" }
-wasm-bindgen-test = { version = "0.3.42" }
-wild = { version = "2" }
-zip = { version = "0.6.6", default-features = false }

-[workspace.metadata.cargo-shear]
-ignored = ["getrandom", "ruff_options_metadata", "uuid"]
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+cacache = { version = "10.0.1" } # uses async-std
+clearscreen = { version = "1.0.10" } # uses which

+# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
+# For (future) wasm-pack support
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.2.7", features = ["js"] }

-[workspace.lints.rust]
-unsafe_code = "warn"
-unreachable_pub = "warn"
-unexpected_cfgs = { level = "warn", check-cfg = [
-    "cfg(fuzzing)",
-    "cfg(codspeed)",
-] }
+[dev-dependencies]
+assert_cmd = { version = "2.0.4" }
+criterion = { version = "0.4.0" }
+insta = { version = "1.19.1", features = ["yaml"] }
+test-case = { version = "2.2.2" }

-[workspace.lints.clippy]
-pedantic = { level = "warn", priority = -2 }
-# Allowed pedantic lints
-char_lit_as_u8 = "allow"
-collapsible_else_if = "allow"
-collapsible_if = "allow"
-implicit_hasher = "allow"
-map_unwrap_or = "allow"
-match_same_arms = "allow"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-module_name_repetitions = "allow"
-must_use_candidate = "allow"
-similar_names = "allow"
-single_match_else = "allow"
-too_many_lines = "allow"
-needless_continue = "allow"       # An explicit continue can be more readable, especially if the alternative is an empty block.
-unnecessary_debug_formatting = "allow"  # too many instances, the display also doesn't quote the path which is often desired in logs where we use them the most often.
-# Without the hashes we run into a `rustfmt` bug in some snapshot tests, see #13250
-needless_raw_string_hashes = "allow"
-# Disallowed restriction lints
-print_stdout = "warn"
-print_stderr = "warn"
-dbg_macro = "warn"
-empty_drop = "warn"
-empty_structs_with_brackets = "warn"
-exit = "warn"
-get_unwrap = "warn"
-rc_buffer = "warn"
-rc_mutex = "warn"
-rest_pat_in_fully_bound_structs = "warn"
-# nursery rules
-redundant_clone = "warn"
-debug_assert_with_mut_call = "warn"
-unused_peekable = "warn"
-
-# Diagnostics are not actionable: Enable once https://github.com/rust-lang/rust-clippy/issues/13774 is resolved.
-large_stack_arrays = "allow"
+[features]
+default = ["update-informer"]
+update-informer = ["dep:update-informer"]

 [profile.release]
-# Note that we set these explicitly, and these values
-# were chosen based on a trade-off between compile times
-# and runtime performance[1].
-#
-# [1]: https://github.com/astral-sh/ruff/pull/9031
+panic = "abort"
 lto = "thin"
-codegen-units = 16
-
-# Some crates don't change as much but benefit more from
-# more expensive optimization passes, so we selectively
-# decrease codegen-units in some cases.
-[profile.release.package.ruff_python_parser]
-codegen-units = 1
-[profile.release.package.ruff_python_ast]
 codegen-units = 1
+opt-level = 3

 [profile.dev.package.insta]
 opt-level = 3
@@ -260,20 +78,6 @@ opt-level = 3
 [profile.dev.package.similar]
 opt-level = 3

-[profile.dev.package.salsa]
-opt-level = 3
-
-# Reduce complexity of a parser function that would trigger a locals limit in a wasm tool.
-# https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wasmparser/src/limits.rs#L29
-[profile.dev.package.ruff_python_parser]
-opt-level = 1
-
-# Use the `--profile profiling` flag to show symbols in release mode.
-# e.g. `cargo build --profile profiling`
-[profile.profiling]
-inherits = "release"
-debug = 1
-
-# The profile that 'cargo dist' will build with.
-[profile.dist]
-inherits = "release"
+[[bench]]
+name = "source_code_locator"
+harness = false
--- a/38
+++ b/38
@@ -1,38 +0,0 @@
-FROM --platform=$BUILDPLATFORM ubuntu AS build
-ENV HOME="/root"
-WORKDIR $HOME
-
-RUN apt update && apt install -y build-essential curl python3-venv
-
-# Setup zig as cross compiling linker
-RUN python3 -m venv $HOME/.venv
-RUN .venv/bin/pip install cargo-zigbuild
-ENV PATH="$HOME/.venv/bin:$PATH"
-
-# Install rust
-ARG TARGETPLATFORM
-RUN case "$TARGETPLATFORM" in \
-    "linux/arm64") echo "aarch64-unknown-linux-musl" > rust_target.txt ;; \
-    "linux/amd64") echo "x86_64-unknown-linux-musl" > rust_target.txt ;; \
-    *) exit 1 ;; \
-    esac
-# Update rustup whenever we bump the rust version
-COPY rust-toolchain.toml rust-toolchain.toml
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --target $(cat rust_target.txt) --profile minimal --default-toolchain none
-ENV PATH="$HOME/.cargo/bin:$PATH"
-# Installs the correct toolchain version from rust-toolchain.toml and then the musl target
-RUN rustup target add $(cat rust_target.txt)
-
-# Build
-COPY crates crates
-COPY Cargo.toml Cargo.toml
-COPY Cargo.lock Cargo.lock
-RUN cargo zigbuild --bin ruff --target $(cat rust_target.txt) --release
-RUN cp target/$(cat rust_target.txt)/release/ruff /ruff
-# TODO: Optimize binary size, with a version that also works when cross compiling
-# RUN strip --strip-all /ruff
-
-FROM scratch
-COPY --from=build /ruff /ruff
-WORKDIR /io
-ENTRYPOINT ["/ruff"]
--- a/1377
+++ b/1377
--- a/README.md
+++ b/README.md
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,15 +0,0 @@
-# Security policy
-
-## Reporting a vulnerability
-
-If you have found a possible vulnerability, please email `security at astral dot sh`.
-
-## Bug bounties
-
-While we sincerely appreciate and encourage reports of suspected security problems, please note that
-Astral does not currently run any bug bounty programs.
-
-## Vulnerability disclosures
-
-Critical vulnerabilities will be disclosed via GitHub's
-[security advisory](https://github.com/astral-sh/ruff/security) system.
--- a/_typos.toml
+++ b/_typos.toml
@@ -1,37 +0,0 @@
-[files]
-# https://github.com/crate-ci/typos/issues/868
-extend-exclude = [
-    "crates/ty_vendored/vendor/**/*",
-    "**/resources/**/*",
-    "**/snapshots/**/*",
-    # Completion tests tend to have a lot of incomplete
-    # words naturally. It's annoying to have to make all
-    # of them actually words. So just ignore typos here.
-    "crates/ty_ide/src/completion.rs",
-]
-
-[default.extend-words]
-"arange" = "arange"  # e.g. `numpy.arange`
-hel = "hel"
-whos = "whos"
-spawnve = "spawnve"
-ned = "ned"
-pn = "pn"  # `import panel as pn` is a thing
-poit = "poit"
-BA = "BA" # acronym for "Bad Allowed", used in testing.
-jod = "jod" # e.g., `jod-thread`
-Numer = "Numer" # Library name 'NumerBlox' in "Who's Using Ruff?"
-
-[default]
-extend-ignore-re = [
-    # Line ignore with trailing "spellchecker:disable-line"
-    "(?Rm)^.*#\\s*spellchecker:disable-line$",
-    "LICENSEs",
-    # Various third party dependencies uses `typ` as struct field names (e.g., lsp_types::LogMessageParams)
-    "typ",
-    # TODO: Remove this once the `TYP` redirects are removed from `rule_redirects.rs`
-    "TYP",
-]
-
-[default.extend-identifiers]
-"FrIeNdLy" = "FrIeNdLy"
--- a/assets/badge/format.json
+++ b/assets/badge/format.json
@@ -1,8 +0,0 @@
-{
-  "label": "code style",
-  "message": "Ruff",
-  "logoSvg": "<svg width=\"510\" height=\"622\" viewBox=\"0 0 510 622\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M206.701 0C200.964 0 196.314 4.64131 196.314 10.3667V41.4667C196.314 47.192 191.663 51.8333 185.927 51.8333H156.843C151.107 51.8333 146.456 56.4746 146.456 62.2V145.133C146.456 150.859 141.806 155.5 136.069 155.5H106.986C101.249 155.5 96.5988 160.141 96.5988 165.867V222.883C96.5988 228.609 91.9484 233.25 86.2118 233.25H57.1283C51.3917 233.25 46.7413 237.891 46.7413 243.617V300.633C46.7413 306.359 42.0909 311 36.3544 311H10.387C4.6504 311 0 315.641 0 321.367V352.467C0 358.192 4.6504 362.833 10.387 362.833H145.418C151.154 362.833 155.804 367.475 155.804 373.2V430.217C155.804 435.942 151.154 440.583 145.418 440.583H116.334C110.597 440.583 105.947 445.225 105.947 450.95V507.967C105.947 513.692 101.297 518.333 95.5601 518.333H66.4766C60.74 518.333 56.0896 522.975 56.0896 528.7V611.633C56.0896 617.359 60.74 622 66.4766 622H149.572C155.309 622 159.959 617.359 159.959 611.633V570.167H201.507C207.244 570.167 211.894 565.525 211.894 559.8V528.7C211.894 522.975 216.544 518.333 222.281 518.333H251.365C257.101 518.333 261.752 513.692 261.752 507.967V476.867C261.752 471.141 266.402 466.5 272.138 466.5H301.222C306.959 466.5 311.609 461.859 311.609 456.133V425.033C311.609 419.308 316.259 414.667 321.996 414.667H351.079C356.816 414.667 361.466 410.025 361.466 404.3V373.2C361.466 367.475 366.117 362.833 371.853 362.833H400.937C406.673 362.833 411.324 358.192 411.324 352.467V321.367C411.324 315.641 415.974 311 421.711 311H450.794C456.531 311 461.181 306.359 461.181 300.633V217.7C461.181 211.975 456.531 207.333 450.794 207.333H420.672C414.936 207.333 410.285 202.692 410.285 196.967V165.867C410.285 160.141 414.936 155.5 420.672 155.5H449.756C455.492 155.5 460.143 150.859 460.143 145.133V114.033C460.143 108.308 464.793 103.667 470.53 103.667H499.613C505.35 103.667 510 99.0253 510 93.3V10.3667C510 4.64132 505.35 0 499.613 0H206.701ZM168.269 440.583C162.532 440.583 157.882 445.225 157.882 450.95V507.967C157.882 513.692 153.231 518.333 147.495 518.333H118.411C112.675 518.333 108.024 522.975 108.024 528.7V559.8C108.024 565.525 112.675 570.167 118.411 570.167H159.959V528.7C159.959 522.975 164.61 518.333 170.346 518.333H199.43C205.166 518.333 209.817 513.692 209.817 507.967V476.867C209.817 471.141 214.467 466.5 220.204 466.5H249.287C255.024 466.5 259.674 461.859 259.674 456.133V425.033C259.674 419.308 264.325 414.667 270.061 414.667H299.145C304.881 414.667 309.532 410.025 309.532 404.3V373.2C309.532 367.475 314.182 362.833 319.919 362.833H349.002C354.739 362.833 359.389 358.192 359.389 352.467V321.367C359.389 315.641 364.039 311 369.776 311H398.859C404.596 311 409.246 306.359 409.246 300.633V269.533C409.246 263.808 404.596 259.167 398.859 259.167H318.88C313.143 259.167 308.493 254.525 308.493 248.8V217.7C308.493 211.975 313.143 207.333 318.88 207.333H347.963C353.7 207.333 358.35 202.692 358.35 196.967V165.867C358.35 160.141 363.001 155.5 368.737 155.5H397.821C403.557 155.5 408.208 150.859 408.208 145.133V114.033C408.208 108.308 412.858 103.667 418.595 103.667H447.678C453.415 103.667 458.065 99.0253 458.065 93.3V62.2C458.065 56.4746 453.415 51.8333 447.678 51.8333H208.778C203.041 51.8333 198.391 56.4746 198.391 62.2V145.133C198.391 150.859 193.741 155.5 188.004 155.5H158.921C153.184 155.5 148.534 160.141 148.534 165.867V222.883C148.534 228.609 143.883 233.25 138.147 233.25H109.063C103.327 233.25 98.6762 237.891 98.6762 243.617V300.633C98.6762 306.359 103.327 311 109.063 311H197.352C203.089 311 207.739 315.641 207.739 321.367V430.217C207.739 435.942 203.089 440.583 197.352 440.583H168.269Z\" fill=\"#D7FF64\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#261230"
-}
--- a/assets/badge/v0.json
+++ b/assets/badge/v0.json
@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"128\" height=\"128\"><path d=\"M115.36 61.84 70.22 50.49 114.45 2.4a1.222 1.222 0 0 0-1.54-1.87L12.3 61.98c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99z\" style=\"fill:#fcc21b\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#E15759"
-}
--- a/assets/badge/v1.json
+++ b/assets/badge/v1.json
@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"109\" height=\"132\" fill=\"none\"><g filter=\"url(#a)\"><path fill=\"#FCC21B\" d=\"m103.642 61.492-45.14-11.35 44.23-48.09a1.222 1.222 0 0 0-1.54-1.87L.582 61.632c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99Z\"/></g><defs><filter id=\"a\" width=\"108.569\" height=\"131.302\" x=\"0\" y=\"0\" color-interpolation-filters=\"sRGB\" filterUnits=\"userSpaceOnUse\"><feFlood flood-opacity=\"0\" result=\"BackgroundImageFix\"/><feColorMatrix in=\"SourceAlpha\" result=\"hardAlpha\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0\"/><feOffset dx=\"4\" dy=\"4\"/><feComposite in2=\"hardAlpha\" operator=\"out\"/><feColorMatrix values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0\"/><feBlend in2=\"BackgroundImageFix\" result=\"effect1_dropShadow_7_4\"/><feBlend in=\"SourceGraphic\" in2=\"effect1_dropShadow_7_4\" result=\"shape\"/></filter></defs></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#E15759"
-}
--- a/assets/badge/v2.json
+++ b/assets/badge/v2.json
@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg width=\"510\" height=\"622\" viewBox=\"0 0 510 622\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M206.701 0C200.964 0 196.314 4.64131 196.314 10.3667V41.4667C196.314 47.192 191.663 51.8333 185.927 51.8333H156.843C151.107 51.8333 146.456 56.4746 146.456 62.2V145.133C146.456 150.859 141.806 155.5 136.069 155.5H106.986C101.249 155.5 96.5988 160.141 96.5988 165.867V222.883C96.5988 228.609 91.9484 233.25 86.2118 233.25H57.1283C51.3917 233.25 46.7413 237.891 46.7413 243.617V300.633C46.7413 306.359 42.0909 311 36.3544 311H10.387C4.6504 311 0 315.641 0 321.367V352.467C0 358.192 4.6504 362.833 10.387 362.833H145.418C151.154 362.833 155.804 367.475 155.804 373.2V430.217C155.804 435.942 151.154 440.583 145.418 440.583H116.334C110.597 440.583 105.947 445.225 105.947 450.95V507.967C105.947 513.692 101.297 518.333 95.5601 518.333H66.4766C60.74 518.333 56.0896 522.975 56.0896 528.7V611.633C56.0896 617.359 60.74 622 66.4766 622H149.572C155.309 622 159.959 617.359 159.959 611.633V570.167H201.507C207.244 570.167 211.894 565.525 211.894 559.8V528.7C211.894 522.975 216.544 518.333 222.281 518.333H251.365C257.101 518.333 261.752 513.692 261.752 507.967V476.867C261.752 471.141 266.402 466.5 272.138 466.5H301.222C306.959 466.5 311.609 461.859 311.609 456.133V425.033C311.609 419.308 316.259 414.667 321.996 414.667H351.079C356.816 414.667 361.466 410.025 361.466 404.3V373.2C361.466 367.475 366.117 362.833 371.853 362.833H400.937C406.673 362.833 411.324 358.192 411.324 352.467V321.367C411.324 315.641 415.974 311 421.711 311H450.794C456.531 311 461.181 306.359 461.181 300.633V217.7C461.181 211.975 456.531 207.333 450.794 207.333H420.672C414.936 207.333 410.285 202.692 410.285 196.967V165.867C410.285 160.141 414.936 155.5 420.672 155.5H449.756C455.492 155.5 460.143 150.859 460.143 145.133V114.033C460.143 108.308 464.793 103.667 470.53 103.667H499.613C505.35 103.667 510 99.0253 510 93.3V10.3667C510 4.64132 505.35 0 499.613 0H206.701ZM168.269 440.583C162.532 440.583 157.882 445.225 157.882 450.95V507.967C157.882 513.692 153.231 518.333 147.495 518.333H118.411C112.675 518.333 108.024 522.975 108.024 528.7V559.8C108.024 565.525 112.675 570.167 118.411 570.167H159.959V528.7C159.959 522.975 164.61 518.333 170.346 518.333H199.43C205.166 518.333 209.817 513.692 209.817 507.967V476.867C209.817 471.141 214.467 466.5 220.204 466.5H249.287C255.024 466.5 259.674 461.859 259.674 456.133V425.033C259.674 419.308 264.325 414.667 270.061 414.667H299.145C304.881 414.667 309.532 410.025 309.532 404.3V373.2C309.532 367.475 314.182 362.833 319.919 362.833H349.002C354.739 362.833 359.389 358.192 359.389 352.467V321.367C359.389 315.641 364.039 311 369.776 311H398.859C404.596 311 409.246 306.359 409.246 300.633V269.533C409.246 263.808 404.596 259.167 398.859 259.167H318.88C313.143 259.167 308.493 254.525 308.493 248.8V217.7C308.493 211.975 313.143 207.333 318.88 207.333H347.963C353.7 207.333 358.35 202.692 358.35 196.967V165.867C358.35 160.141 363.001 155.5 368.737 155.5H397.821C403.557 155.5 408.208 150.859 408.208 145.133V114.033C408.208 108.308 412.858 103.667 418.595 103.667H447.678C453.415 103.667 458.065 99.0253 458.065 93.3V62.2C458.065 56.4746 453.415 51.8333 447.678 51.8333H208.778C203.041 51.8333 198.391 56.4746 198.391 62.2V145.133C198.391 150.859 193.741 155.5 188.004 155.5H158.921C153.184 155.5 148.534 160.141 148.534 165.867V222.883C148.534 228.609 143.883 233.25 138.147 233.25H109.063C103.327 233.25 98.6762 237.891 98.6762 243.617V300.633C98.6762 306.359 103.327 311 109.063 311H197.352C203.089 311 207.739 315.641 207.739 321.367V430.217C207.739 435.942 203.089 440.583 197.352 440.583H168.269Z\" fill=\"#D7FF64\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#261230"
-}
--- a/assets/png/Astral.png
+++ b/assets/png/Astral.png
--- a/assets/svg/Astral.svg
+++ b/assets/svg/Astral.svg
@@ -1,24 +0,0 @@
-<svg width="139" height="24" viewBox="0 0 139 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <rect width="138.764" height="24" rx="2.18182" fill="#261230"/>
-  <path
-    d="M8.72798 15.2726H9.91316V11.8697L9.6887 10.4062L9.8952 10.3343L12.1309 15.1649L14.3486 10.3343L14.5461 10.4062L14.3486 11.8607V15.2726H15.5248V8.72714H13.9535L12.2117 12.7137H12.0142L10.2723 8.72714H8.72798V15.2726Z"
-    fill="#D7FF64"/>
-  <path
-    d="M22.3432 15.2726H23.6631L21.3017 8.72714H19.7574L17.4589 15.2726H18.7069L19.1558 13.9797H21.9033L22.3432 15.2726ZM19.497 13.0279L19.901 11.8607L20.4308 10.0021H20.6463L21.176 11.8607L21.5711 13.0279H19.497Z"
-    fill="#D7FF64"/>
-  <path
-    d="M25.4209 15.2726H28.1234C30.1077 15.2726 30.9876 14.1413 30.9876 12.0044C30.9876 9.92131 30.1706 8.72714 28.1234 8.72714H25.4209V15.2726ZM26.624 14.2131V9.77765H28.0965C29.147 9.77765 29.7306 10.1907 29.7306 11.4477V12.5521C29.7306 13.6923 29.2817 14.2131 28.0965 14.2131H26.624Z"
-    fill="#D7FF64"/>
-  <path
-    d="M33.079 15.2726H37.6491V14.2131H34.2822V12.3815H37.2002V11.3938H34.2822V9.77765H37.6491V8.72714H33.079V15.2726Z"
-    fill="#D7FF64"/>
-  <path
-    d="M42.923 15.2726H46.2451C47.4572 15.2726 48.2025 14.5812 48.2025 13.5487C48.2025 12.7675 47.8343 12.175 47.0532 11.9954V11.7799C47.6637 11.5734 48.0319 11.0436 48.0319 10.3433C48.0319 9.38259 47.4572 8.72714 46.281 8.72714H42.923V15.2726ZM44.0992 11.4746V9.65195H45.9578C46.4875 9.65195 46.7928 9.92131 46.7928 10.3523V10.7653C46.7928 11.1873 46.4965 11.4746 45.9758 11.4746H44.0992ZM44.0992 14.3388V12.3904H46.0296C46.5863 12.3904 46.9365 12.6418 46.9365 13.1806V13.5666C46.9365 14.0425 46.5684 14.3388 45.9309 14.3388H44.0992Z"
-    fill="#D7FF64"/>
-  <path
-    d="M49.6959 8.72714L52.174 12.579V14.1952H50.1898V15.2726H53.3772V12.579L55.8553 8.72714H54.4456L53.5119 10.2535L52.8744 11.3759H52.6679L52.0483 10.2715L51.1056 8.72714H49.6959Z"
-    fill="#D7FF64"/>
-  <path fill-rule="evenodd" clip-rule="evenodd"
-    d="M74.1824 7.63626C74.1824 7.03377 74.6708 6.54535 75.2733 6.54535H84.0006C84.6031 6.54535 85.0915 7.03377 85.0915 7.63626V9.81808H80.0733V8.94535H79.2006V10.6908H84.0006C84.6031 10.6908 85.0915 11.1792 85.0915 11.7817V16.3635C85.0915 16.966 84.6031 17.4544 84.0006 17.4544H75.2733C74.6708 17.4544 74.1824 16.966 74.1824 16.3635V14.1817L79.2006 14.1817V15.0544H80.0733V13.309L75.2733 13.309C74.6708 13.309 74.1824 12.8206 74.1824 12.2181V7.63626ZM63.4912 6.54545C62.8887 6.54545 62.4003 7.03387 62.4003 7.63636V17.4545H67.4185V14.1818H68.2912V17.4545H73.3094V7.63636C73.3094 7.03387 72.821 6.54545 72.2185 6.54545H63.4912ZM69.164 10.6909V11.5636H66.5458V10.6909H69.164ZM110.619 6.54545C110.016 6.54545 109.528 7.03387 109.528 7.63636V17.4545H114.546V14.1818H115.419V17.4545H120.437V7.63636C120.437 7.03387 119.948 6.54545 119.346 6.54545H110.619ZM116.291 10.6909V11.5636H113.673V10.6909H116.291ZM91.8549 8.29091H96.8731V11.3455C96.8731 11.9479 96.3847 12.4364 95.7822 12.4364H91.8549V13.3091H96.8731V17.4545H87.9276C87.3251 17.4545 86.8367 16.9661 86.8367 16.3636V12.4364H85.964V8.29091H86.8367V6.54545H91.8549V8.29091ZM108.655 7.63636C108.655 7.03387 108.166 6.54545 107.564 6.54545H97.7458V17.4545H102.764V14.1818H103.637V17.4545H108.655V13.3091H106.473V12.4364H107.564C108.166 12.4364 108.655 11.9479 108.655 11.3455V7.63636ZM104.509 10.6909V11.5636H101.891V10.6909H104.509ZM132.218 13.3091L126.327 13.3091V6.54547L121.309 6.54547V17.4546H132.218V13.3091Z"
-    fill="#D7FF64"/>
-</svg>
--- a/benches/source_code_locator.rs
+++ b/benches/source_code_locator.rs
@@ -0,0 +1,18 @@
+use std::path::Path;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ropey::Rope;
+use ruff::fs;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
+    c.bench_function("rope", |b| {
+        b.iter(|| {
+            let rope = Rope::from_str(black_box(&contents));
+            rope.line_to_char(black_box(4));
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,26 +0,0 @@
-doc-valid-idents = [
-    "..",
-    "CodeQL",
-    "CPython",
-    "FastAPI",
-    "IPython",
-    "LangChain",
-    "LibCST",
-    "McCabe",
-    "NumPy",
-    "SCREAMING_SNAKE_CASE",
-    "SQLAlchemy",
-    "StackOverflow",
-    "PyCharm",
-    "SNMPv1",
-    "SNMPv2",
-    "SNMPv3",
-    "PyFlakes",
-]
-
-ignore-interior-mutability = [
-    # Interned is read-only. The wrapped `Rc` never gets updated.
-    "ruff_formatter::format_element::Interned",
-    # The expression is read-only.
-    "ruff_python_ast::hashable::HashableExpr",
-]
--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,91 +0,0 @@
-[package]
-name = "ruff"
-version = "0.11.12"
-publish = true
-authors = { workspace = true }
-edition = { workspace = true }
-rust-version = { workspace = true }
-homepage = { workspace = true }
-documentation = { workspace = true }
-repository = { workspace = true }
-license = { workspace = true }
-readme = "../../README.md"
-default-run = "ruff"
-
-[dependencies]
-ruff_cache = { workspace = true }
-ruff_db = { workspace = true, default-features = false, features = ["os"] }
-ruff_diagnostics = { workspace = true }
-ruff_graph = { workspace = true, features = ["serde", "clap"] }
-ruff_linter = { workspace = true, features = ["clap"] }
-ruff_macros = { workspace = true }
-ruff_notebook = { workspace = true }
-ruff_options_metadata = { workspace = true, features = ["serde"] }
-ruff_python_ast = { workspace = true }
-ruff_python_formatter = { workspace = true }
-ruff_python_parser = { workspace = true }
-ruff_server = { workspace = true }
-ruff_source_file = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_workspace = { workspace = true }
-
-anyhow = { workspace = true }
-argfile = { workspace = true }
-bincode = { workspace = true, features = ["serde"] }
-bitflags = { workspace = true }
-cachedir = { workspace = true }
-clap = { workspace = true, features = ["derive", "env", "wrap_help"] }
-clap_complete_command = { workspace = true }
-clearscreen = { workspace = true }
-colored = { workspace = true }
-filetime = { workspace = true }
-globwalk = { workspace = true }
-ignore = { workspace = true }
-is-macro = { workspace = true }
-itertools = { workspace = true }
-jiff = { workspace = true }
-log = { workspace = true }
-notify = { workspace = true }
-path-absolutize = { workspace = true, features = ["once_cell_cache"] }
-rayon = { workspace = true }
-regex = { workspace = true }
-rustc-hash = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-shellexpand = { workspace = true }
-strum = { workspace = true, features = [] }
-tempfile = { workspace = true }
-thiserror = { workspace = true }
-toml = { workspace = true }
-tracing = { workspace = true, features = ["log"] }
-walkdir = { workspace = true }
-wild = { workspace = true }
-
-[dev-dependencies]
-# Enable test rules during development
-ruff_linter = { workspace = true, features = ["clap", "test-rules"] }
-
-assert_fs = { workspace = true }
-# Avoid writing colored snapshots when running tests from the terminal
-colored = { workspace = true, features = ["no-color"] }
-indoc = { workspace = true }
-insta = { workspace = true, features = ["filters", "json"] }
-insta-cmd = { workspace = true }
-tempfile = { workspace = true }
-test-case = { workspace = true }
-
-[package.metadata.cargo-shear]
-# Used via macro expansion.
-ignored = ["jiff"]
-
-[package.metadata.dist]
-dist = true
-
-[target.'cfg(target_os = "windows")'.dependencies]
-mimalloc = { workspace = true }
-
-[target.'cfg(all(not(target_os = "windows"), not(target_os = "openbsd"), not(target_os = "aix"), not(target_os = "android"), any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "powerpc64")))'.dependencies]
-tikv-jemallocator = { workspace = true }
-
-[lints]
-workspace = true
--- a/crates/ruff/build.rs
+++ b/crates/ruff/build.rs
@@ -1,105 +0,0 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-    process::Command,
-};
-
-fn main() {
-    // The workspace root directory is not available without walking up the tree
-    // https://github.com/rust-lang/cargo/issues/3946
-    let workspace_root = Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap())
-        .join("..")
-        .join("..");
-
-    commit_info(&workspace_root);
-
-    let target = std::env::var("TARGET").unwrap();
-    println!("cargo::rustc-env=RUST_HOST_TARGET={target}");
-}
-
-fn commit_info(workspace_root: &Path) {
-    // If not in a git repository, do not attempt to retrieve commit information
-    let git_dir = workspace_root.join(".git");
-    if !git_dir.exists() {
-        return;
-    }
-
-    if let Some(git_head_path) = git_head(&git_dir) {
-        println!("cargo:rerun-if-changed={}", git_head_path.display());
-
-        let git_head_contents = fs::read_to_string(git_head_path);
-        if let Ok(git_head_contents) = git_head_contents {
-            // The contents are either a commit or a reference in the following formats
-            // - "<commit>" when the head is detached
-            // - "ref <ref>" when working on a branch
-            // If a commit, checking if the HEAD file has changed is sufficient
-            // If a ref, we need to add the head file for that ref to rebuild on commit
-            let mut git_ref_parts = git_head_contents.split_whitespace();
-            git_ref_parts.next();
-            if let Some(git_ref) = git_ref_parts.next() {
-                let git_ref_path = git_dir.join(git_ref);
-                println!("cargo:rerun-if-changed={}", git_ref_path.display());
-            }
-        }
-    }
-
-    let output = match Command::new("git")
-        .arg("log")
-        .arg("-1")
-        .arg("--date=short")
-        .arg("--abbrev=9")
-        .arg("--format=%H %h %cd %(describe:tags)")
-        .output()
-    {
-        Ok(output) if output.status.success() => output,
-        _ => return,
-    };
-    let stdout = String::from_utf8(output.stdout).unwrap();
-    let mut parts = stdout.split_whitespace();
-    let mut next = || parts.next().unwrap();
-    println!("cargo::rustc-env=RUFF_COMMIT_HASH={}", next());
-    println!("cargo::rustc-env=RUFF_COMMIT_SHORT_HASH={}", next());
-    println!("cargo::rustc-env=RUFF_COMMIT_DATE={}", next());
-
-    // Describe can fail for some commits
-    // https://git-scm.com/docs/pretty-formats#Documentation/pretty-formats.txt-emdescribeoptionsem
-    if let Some(describe) = parts.next() {
-        let mut describe_parts = describe.split('-');
-        println!(
-            "cargo::rustc-env=RUFF_LAST_TAG={}",
-            describe_parts.next().unwrap()
-        );
-        // If this is the tagged commit, this component will be missing
-        println!(
-            "cargo::rustc-env=RUFF_LAST_TAG_DISTANCE={}",
-            describe_parts.next().unwrap_or("0")
-        );
-    }
-}
-
-fn git_head(git_dir: &Path) -> Option<PathBuf> {
-    // The typical case is a standard git repository.
-    let git_head_path = git_dir.join("HEAD");
-    if git_head_path.exists() {
-        return Some(git_head_path);
-    }
-    if !git_dir.is_file() {
-        return None;
-    }
-    // If `.git/HEAD` doesn't exist and `.git` is actually a file,
-    // then let's try to attempt to read it as a worktree. If it's
-    // a worktree, then its contents will look like this, e.g.:
-    //
-    //     gitdir: /home/andrew/astral/uv/main/.git/worktrees/pr2
-    //
-    // And the HEAD file we want to watch will be at:
-    //
-    //     /home/andrew/astral/uv/main/.git/worktrees/pr2/HEAD
-    let contents = fs::read_to_string(git_dir).ok()?;
-    let (label, worktree_path) = contents.split_once(':')?;
-    if label != "gitdir" {
-        return None;
-    }
-    let worktree_path = worktree_path.trim();
-    Some(PathBuf::from(worktree_path))
-}
--- a/crates/ruff/resources/test/fixtures/cache_mutable/.gitignore
+++ b/crates/ruff/resources/test/fixtures/cache_mutable/.gitignore
@@ -1,2 +0,0 @@
-# Modified by the cache tests.
-source.py
--- a/crates/ruff/resources/test/fixtures/cache_remove_old_files/source.py
+++ b/crates/ruff/resources/test/fixtures/cache_remove_old_files/source.py
@@ -1,4 +0,0 @@
-# NOTE: sync with cache::invalidation test
-a = 1
-
-__all__ = list(["a", "b"])
--- a/crates/ruff/resources/test/fixtures/formatted.py
+++ b/crates/ruff/resources/test/fixtures/formatted.py
@@ -1 +0,0 @@
-print("All formatted!")
--- a/crates/ruff/resources/test/fixtures/include-test/a.py
+++ b/crates/ruff/resources/test/fixtures/include-test/a.py
--- a/crates/ruff/resources/test/fixtures/include-test/b.py
+++ b/crates/ruff/resources/test/fixtures/include-test/b.py
--- a/crates/ruff/resources/test/fixtures/include-test/nested-project/e.py
+++ b/crates/ruff/resources/test/fixtures/include-test/nested-project/e.py
--- a/crates/ruff/resources/test/fixtures/include-test/nested-project/pyproject.toml
+++ b/crates/ruff/resources/test/fixtures/include-test/nested-project/pyproject.toml
@@ -1,2 +0,0 @@
-[tool.ruff]
-select = []
--- a/crates/ruff/resources/test/fixtures/include-test/pyproject.toml
+++ b/crates/ruff/resources/test/fixtures/include-test/pyproject.toml
@@ -1,2 +0,0 @@
-[tool.ruff]
-include = ["a.py", "subdirectory/c.py"]
--- a/crates/ruff/resources/test/fixtures/include-test/subdirectory/c.py
+++ b/crates/ruff/resources/test/fixtures/include-test/subdirectory/c.py
--- a/crates/ruff/resources/test/fixtures/include-test/subdirectory/d.py
+++ b/crates/ruff/resources/test/fixtures/include-test/subdirectory/d.py
--- a/crates/ruff/resources/test/fixtures/trailing_semicolon.ipynb
+++ b/crates/ruff/resources/test/fixtures/trailing_semicolon.ipynb
@@ -1,413 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "4f8ce941-1492-4d4e-8ab5-70d733fe891a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%config ZMQInteractiveShell.ast_node_interactivity=\"last_expr_or_assign\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "721ec705-0c65-4bfb-9809-7ed8bc534186",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Assignment statement without a semicolon\n",
-    "x = 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "de50e495-17e5-41cc-94bd-565757555d7e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Assignment statement with a semicolon\n",
-    "x = 1;\n",
-    "x = 1;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "39e31201-23da-44eb-8684-41bba3663991",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Augmented assignment without a semicolon\n",
-    "x += 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "6b73d3dd-c73a-4697-9e97-e109a6c1fbab",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Augmented assignment without a semicolon\n",
-    "x += 1;\n",
-    "x += 1;  # comment\n",
-    "# comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "2a3e5b86-aa5b-46ba-b9c6-0386d876f58c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Multiple assignment without a semicolon\n",
-    "x = y = 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "07f89e51-9357-4cfb-8fc5-76fb75e35949",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Multiple assignment with a semicolon\n",
-    "x = y = 1;\n",
-    "x = y = 1;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "c22b539d-473e-48f8-a236-625e58c47a00",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Tuple unpacking without a semicolon\n",
-    "x, y = 1, 2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "12c87940-a0d5-403b-a81c-7507eb06dc7e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Tuple unpacking with a semicolon (irrelevant)\n",
-    "x, y = 1, 2;\n",
-    "x, y = 1, 2;  # comment\n",
-    "# comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "5a768c76-6bc4-470c-b37e-8cc14bc6caf4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Annotated assignment statement without a semicolon\n",
-    "x: int = 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "21bfda82-1a9a-4ba1-9078-74ac480804b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Annotated assignment statement without a semicolon\n",
-    "x: int = 1;\n",
-    "x: int = 1;  # comment\n",
-    "# comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "09929999-ff29-4d10-ad2b-e665af15812d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Assignment expression without a semicolon\n",
-    "(x := 1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "32a83217-1bad-4f61-855e-ffcdb119c763",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Assignment expression with a semicolon\n",
-    "(x := 1);\n",
-    "(x := 1);  # comment\n",
-    "# comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "61b81865-277e-4964-b03e-eb78f1f318eb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x = 1\n",
-    "# Expression without a semicolon\n",
-    "x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "974c29be-67e1-4000-95fa-6ca118a63bad",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "x = 1\n",
-    "# Expression with a semicolon\n",
-    "x;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "cfeb1757-46d6-4f13-969f-a283b6d0304f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Point:\n",
-    "    def __init__(self, x, y):\n",
-    "        self.x = x\n",
-    "        self.y = y\n",
-    "\n",
-    "\n",
-    "p = Point(0, 0);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "2ee7f1a5-ccfe-4004-bfa4-ef834a58da97",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Assignment statement where the left is an attribute access doesn't\n",
-    "# print the value.\n",
-    "p.x = 1;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "3e49370a-048b-474d-aa0a-3d1d4a73ad37",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = {}\n",
-    "\n",
-    "# Neither does the subscript node\n",
-    "data[\"foo\"] = 1;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "d594bdd3-eaa9-41ef-8cda-cf01bc273b2d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if (x := 1):\n",
-    "    # It should be the top level statement\n",
-    "    x"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "e532f0cf-80c7-42b7-8226-6002fcf74fb6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Parentheses with comments\n",
-    "(\n",
-    "    x := 1  # comment\n",
-    ")  # comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "473c5d62-871b-46ed-8a34-27095243f462",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Parentheses with comments\n",
-    "(\n",
-    "    x := 1  # comment\n",
-    ");  # comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "8c3c2361-f49f-45fe-bbe3-7e27410a8a86",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Hello world!'"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "\"\"\"Hello world!\"\"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "23dbe9b5-3f68-4890-ab2d-ab0dbfd0712a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\"\"\"Hello world!\"\"\";  # comment\n",
-    "# comment"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "3ce33108-d95d-4c70-83d1-0d4fd36a2951",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'x = 1'"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x = 1\n",
-    "f\"x = {x}\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "654a4a67-de43-4684-824a-9451c67db48f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "x = 1\n",
-    "f\"x = {x}\";\n",
-    "f\"x = {x}\";  # comment\n",
-    "# comment"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python (ruff-playground)",
-   "language": "python",
-   "name": "ruff-playground"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
--- a/crates/ruff/resources/test/fixtures/unformatted.ipynb
+++ b/crates/ruff/resources/test/fixtures/unformatted.ipynb
@@ -1,72 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "98e1dd71-14a2-454d-9be0-061dde560b07",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy\n",
-    "maths = (numpy.arange(100)**2).sum()\n",
-    "stats= numpy.asarray([1,2,3,4]).median()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "83a0b1b8",
-   "metadata": {},
-   "source": [
-    "A markdown cell"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae12f012",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# A cell with IPython escape command\n",
-    "def some_function(foo, bar):\n",
-    "    pass\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "10f3bbf9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "foo = %pwd\n",
-    "def some_function(foo,bar,):\n",
-    "    # Another cell with IPython escape command\n",
-    "    foo = %pwd\n",
-    "    print(foo)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
--- a/crates/ruff/resources/test/fixtures/unformatted.py
+++ b/crates/ruff/resources/test/fixtures/unformatted.py
@@ -1,3 +0,0 @@
-x = 1
-y=2
-z = 3
--- a/crates/ruff/src/args.rs
+++ b/crates/ruff/src/args.rs
--- a/crates/ruff/src/cache.rs
+++ b/crates/ruff/src/cache.rs
--- a/crates/ruff/src/commands/add_noqa.rs
+++ b/crates/ruff/src/commands/add_noqa.rs
@@ -1,93 +0,0 @@
-use std::path::PathBuf;
-use std::time::Instant;
-
-use anyhow::Result;
-use log::{debug, error};
-#[cfg(not(target_family = "wasm"))]
-use rayon::prelude::*;
-
-use ruff_linter::linter::add_noqa_to_path;
-use ruff_linter::source_kind::SourceKind;
-use ruff_linter::warn_user_once;
-use ruff_python_ast::{PySourceType, SourceType};
-use ruff_workspace::resolver::{
-    PyprojectConfig, ResolvedFile, match_exclusion, python_files_in_path,
-};
-
-use crate::args::ConfigArguments;
-
-/// Add `noqa` directives to a collection of files.
-pub(crate) fn add_noqa(
-    files: &[PathBuf],
-    pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
-) -> Result<usize> {
-    // Collect all the files to check.
-    let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
-    let duration = start.elapsed();
-    debug!("Identified files to lint in: {duration:?}");
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(0);
-    }
-
-    // Discover the package root for each Python file.
-    let package_roots = resolver.package_roots(
-        &paths
-            .iter()
-            .flatten()
-            .map(ResolvedFile::path)
-            .collect::<Vec<_>>(),
-    );
-
-    let start = Instant::now();
-    let modifications: usize = paths
-        .par_iter()
-        .flatten()
-        .filter_map(|resolved_file| {
-            let SourceType::Python(source_type @ (PySourceType::Python | PySourceType::Stub)) =
-                SourceType::from(resolved_file.path())
-            else {
-                return None;
-            };
-            let path = resolved_file.path();
-            let package = resolved_file
-                .path()
-                .parent()
-                .and_then(|parent| package_roots.get(parent))
-                .and_then(|package| *package);
-            let settings = resolver.resolve(path);
-            if (settings.file_resolver.force_exclude || !resolved_file.is_root())
-                && match_exclusion(
-                    resolved_file.path(),
-                    resolved_file.file_name(),
-                    &settings.linter.exclude,
-                )
-            {
-                return None;
-            }
-            let source_kind = match SourceKind::from_path(path, source_type) {
-                Ok(Some(source_kind)) => source_kind,
-                Ok(None) => return None,
-                Err(e) => {
-                    error!("Failed to extract source from {}: {e}", path.display());
-                    return None;
-                }
-            };
-            match add_noqa_to_path(path, package, &source_kind, source_type, &settings.linter) {
-                Ok(count) => Some(count),
-                Err(e) => {
-                    error!("Failed to add noqa to {}: {e}", path.display());
-                    None
-                }
-            }
-        })
-        .sum();
-
-    let duration = start.elapsed();
-    debug!("Added noqa to files in: {duration:?}");
-
-    Ok(modifications)
-}
--- a/crates/ruff/src/commands/analyze_graph.rs
+++ b/crates/ruff/src/commands/analyze_graph.rs
@@ -1,262 +0,0 @@
-use crate::args::{AnalyzeGraphArgs, ConfigArguments};
-use crate::resolve::resolve;
-use crate::{ExitStatus, resolve_default_files};
-use anyhow::Result;
-use log::{debug, warn};
-use path_absolutize::CWD;
-use ruff_db::system::{SystemPath, SystemPathBuf};
-use ruff_graph::{Direction, ImportMap, ModuleDb, ModuleImports};
-use ruff_linter::package::PackageRoot;
-use ruff_linter::{warn_user, warn_user_once};
-use ruff_python_ast::{PySourceType, SourceType};
-use ruff_workspace::resolver::{ResolvedFile, match_exclusion, python_files_in_path};
-use rustc_hash::FxHashMap;
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-
-/// Generate an import map.
-pub(crate) fn analyze_graph(
-    args: AnalyzeGraphArgs,
-    config_arguments: &ConfigArguments,
-) -> Result<ExitStatus> {
-    // Construct the "default" settings. These are used when no `pyproject.toml`
-    // files are present, or files are injected from outside the hierarchy.
-    let pyproject_config = resolve(config_arguments, None)?;
-    if pyproject_config.settings.analyze.preview.is_disabled() {
-        warn_user!("`ruff analyze graph` is experimental and may change without warning");
-    }
-
-    // Write all paths relative to the current working directory.
-    let root =
-        SystemPathBuf::from_path_buf(CWD.clone()).expect("Expected a UTF-8 working directory");
-
-    // Find all Python files.
-    let files = resolve_default_files(args.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(ExitStatus::Success);
-    }
-
-    // Resolve all package roots.
-    let package_roots = resolver
-        .package_roots(
-            &paths
-                .iter()
-                .flatten()
-                .map(ResolvedFile::path)
-                .collect::<Vec<_>>(),
-        )
-        .into_iter()
-        .map(|(path, package)| {
-            (
-                path.to_path_buf(),
-                package.map(PackageRoot::path).map(Path::to_path_buf),
-            )
-        })
-        .collect::<FxHashMap<_, _>>();
-
-    // Create a database from the source roots.
-    let src_roots = package_roots
-        .values()
-        .filter_map(|package| package.as_deref())
-        .filter_map(|package| package.parent())
-        .map(Path::to_path_buf)
-        .filter_map(|path| SystemPathBuf::from_path_buf(path).ok())
-        .collect();
-
-    let db = ModuleDb::from_src_roots(
-        src_roots,
-        pyproject_config
-            .settings
-            .analyze
-            .target_version
-            .as_tuple()
-            .into(),
-        args.python
-            .and_then(|python| SystemPathBuf::from_path_buf(python).ok()),
-    )?;
-
-    let imports = {
-        // Create a cache for resolved globs.
-        let glob_resolver = Arc::new(Mutex::new(GlobResolver::default()));
-
-        // Collect and resolve the imports for each file.
-        let result = Arc::new(Mutex::new(Vec::new()));
-        let inner_result = Arc::clone(&result);
-        let db = db.clone();
-
-        rayon::scope(move |scope| {
-            for resolved_file in paths {
-                let Ok(resolved_file) = resolved_file else {
-                    continue;
-                };
-
-                let path = resolved_file.path();
-                let package = path
-                    .parent()
-                    .and_then(|parent| package_roots.get(parent))
-                    .and_then(Clone::clone);
-
-                // Resolve the per-file settings.
-                let settings = resolver.resolve(path);
-                let string_imports = settings.analyze.detect_string_imports;
-                let include_dependencies = settings.analyze.include_dependencies.get(path).cloned();
-
-                // Skip excluded files.
-                if (settings.file_resolver.force_exclude || !resolved_file.is_root())
-                    && match_exclusion(
-                        resolved_file.path(),
-                        resolved_file.file_name(),
-                        &settings.analyze.exclude,
-                    )
-                {
-                    continue;
-                }
-
-                // Ignore non-Python files.
-                let source_type = match settings.analyze.extension.get(path) {
-                    None => match SourceType::from(&path) {
-                        SourceType::Python(source_type) => source_type,
-                        SourceType::Toml(_) => {
-                            debug!("Ignoring TOML file: {}", path.display());
-                            continue;
-                        }
-                    },
-                    Some(language) => PySourceType::from(language),
-                };
-                if matches!(source_type, PySourceType::Ipynb) {
-                    debug!("Ignoring Jupyter notebook: {}", path.display());
-                    continue;
-                }
-
-                // Convert to system paths.
-                let Ok(package) = package.map(SystemPathBuf::from_path_buf).transpose() else {
-                    warn!("Failed to convert package to system path");
-                    continue;
-                };
-                let Ok(path) = SystemPathBuf::from_path_buf(resolved_file.into_path()) else {
-                    warn!("Failed to convert path to system path");
-                    continue;
-                };
-
-                let db = db.clone();
-                let glob_resolver = glob_resolver.clone();
-                let root = root.clone();
-                let result = inner_result.clone();
-                scope.spawn(move |_| {
-                    // Identify any imports via static analysis.
-                    let mut imports =
-                        ModuleImports::detect(&db, &path, package.as_deref(), string_imports)
-                            .unwrap_or_else(|err| {
-                                warn!("Failed to generate import map for {path}: {err}");
-                                ModuleImports::default()
-                            });
-
-                    debug!("Discovered {} imports for {}", imports.len(), path);
-
-                    // Append any imports that were statically defined in the configuration.
-                    if let Some((root, globs)) = include_dependencies {
-                        let mut glob_resolver = glob_resolver.lock().unwrap();
-                        imports.extend(glob_resolver.resolve(root, globs));
-                    }
-
-                    // Convert the path (and imports) to be relative to the working directory.
-                    let path = path
-                        .strip_prefix(&root)
-                        .map(SystemPath::to_path_buf)
-                        .unwrap_or(path);
-                    let imports = imports.relative_to(&root);
-
-                    result.lock().unwrap().push((path, imports));
-                });
-            }
-        });
-
-        // Collect the results.
-        Arc::into_inner(result).unwrap().into_inner()?
-    };
-
-    // Generate the import map.
-    let import_map = match args.direction {
-        Direction::Dependencies => ImportMap::dependencies(imports),
-        Direction::Dependents => ImportMap::dependents(imports),
-    };
-
-    // Print to JSON.
-    writeln!(
-        std::io::stdout(),
-        "{}",
-        serde_json::to_string_pretty(&import_map)?
-    )?;
-
-    std::mem::forget(db);
-
-    Ok(ExitStatus::Success)
-}
-
-/// A resolver for glob sets.
-#[derive(Default, Debug)]
-struct GlobResolver {
-    cache: GlobCache,
-}
-
-impl GlobResolver {
-    /// Resolve a set of globs, anchored at a given root.
-    fn resolve(&mut self, root: PathBuf, globs: Vec<String>) -> Vec<SystemPathBuf> {
-        if let Some(cached) = self.cache.get(&root, &globs) {
-            return cached.clone();
-        }
-
-        let walker = match globwalk::GlobWalkerBuilder::from_patterns(&root, &globs)
-            .file_type(globwalk::FileType::FILE)
-            .build()
-        {
-            Ok(walker) => walker,
-            Err(err) => {
-                warn!("Failed to read glob walker: {err}");
-                return Vec::new();
-            }
-        };
-
-        let mut paths = Vec::new();
-        for entry in walker {
-            let entry = match entry {
-                Ok(entry) => entry,
-                Err(err) => {
-                    warn!("Failed to read glob entry: {err}");
-                    continue;
-                }
-            };
-            let path = match SystemPathBuf::from_path_buf(entry.into_path()) {
-                Ok(path) => path,
-                Err(err) => {
-                    warn!("Failed to convert path to system path: {}", err.display());
-                    continue;
-                }
-            };
-            paths.push(path);
-        }
-
-        self.cache.insert(root, globs, paths.clone());
-        paths
-    }
-}
-
-/// A cache for resolved globs.
-#[derive(Default, Debug)]
-struct GlobCache(FxHashMap<PathBuf, FxHashMap<Vec<String>, Vec<SystemPathBuf>>>);
-
-impl GlobCache {
-    /// Insert a resolved glob.
-    fn insert(&mut self, root: PathBuf, globs: Vec<String>, paths: Vec<SystemPathBuf>) {
-        self.0.entry(root).or_default().insert(globs, paths);
-    }
-
-    /// Get a resolved glob.
-    fn get(&self, root: &Path, globs: &[String]) -> Option<&Vec<SystemPathBuf>> {
-        self.0.get(root).and_then(|map| map.get(globs))
-    }
-}
--- a/crates/ruff/src/commands/check.rs
+++ b/crates/ruff/src/commands/check.rs
@@ -1,304 +0,0 @@
-use std::fmt::Write;
-use std::io;
-use std::path::{Path, PathBuf};
-use std::time::Instant;
-
-use anyhow::Result;
-use colored::Colorize;
-use ignore::Error;
-use log::{debug, error, warn};
-#[cfg(not(target_family = "wasm"))]
-use rayon::prelude::*;
-use rustc_hash::FxHashMap;
-
-use ruff_db::panic::catch_unwind;
-use ruff_linter::OldDiagnostic;
-use ruff_linter::message::Message;
-use ruff_linter::package::PackageRoot;
-use ruff_linter::registry::Rule;
-use ruff_linter::settings::types::UnsafeFixes;
-use ruff_linter::settings::{LinterSettings, flags};
-use ruff_linter::{IOError, fs, warn_user_once};
-use ruff_source_file::SourceFileBuilder;
-use ruff_text_size::TextRange;
-use ruff_workspace::resolver::{
-    PyprojectConfig, ResolvedFile, match_exclusion, python_files_in_path,
-};
-
-use crate::args::ConfigArguments;
-use crate::cache::{Cache, PackageCacheMap, PackageCaches};
-use crate::diagnostics::Diagnostics;
-
-/// Run the linter over a collection of files.
-pub(crate) fn check(
-    files: &[PathBuf],
-    pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
-    cache: flags::Cache,
-    noqa: flags::Noqa,
-    fix_mode: flags::FixMode,
-    unsafe_fixes: UnsafeFixes,
-) -> Result<Diagnostics> {
-    // Collect all the Python files to check.
-    let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
-    debug!("Identified files to lint in: {:?}", start.elapsed());
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(Diagnostics::default());
-    }
-
-    // Discover the package root for each Python file.
-    let package_roots = resolver.package_roots(
-        &paths
-            .iter()
-            .flatten()
-            .map(ResolvedFile::path)
-            .collect::<Vec<_>>(),
-    );
-
-    // Load the caches.
-    let caches = if cache.is_enabled() {
-        Some(PackageCacheMap::init(&package_roots, &resolver))
-    } else {
-        None
-    };
-
-    let start = Instant::now();
-    let diagnostics_per_file = paths.par_iter().filter_map(|resolved_file| {
-        let result = match resolved_file {
-            Ok(resolved_file) => {
-                let path = resolved_file.path();
-                let package = path
-                    .parent()
-                    .and_then(|parent| package_roots.get(parent))
-                    .and_then(|package| *package);
-
-                let settings = resolver.resolve(path);
-
-                if (settings.file_resolver.force_exclude || !resolved_file.is_root())
-                    && match_exclusion(
-                        resolved_file.path(),
-                        resolved_file.file_name(),
-                        &settings.linter.exclude,
-                    )
-                {
-                    return None;
-                }
-
-                let cache_root = package
-                    .map(PackageRoot::path)
-                    .unwrap_or_else(|| path.parent().unwrap_or(path));
-                let cache = caches.get(cache_root);
-
-                lint_path(
-                    path,
-                    package,
-                    &settings.linter,
-                    cache,
-                    noqa,
-                    fix_mode,
-                    unsafe_fixes,
-                )
-                .map_err(|e| {
-                    (Some(path.to_path_buf()), {
-                        let mut error = e.to_string();
-                        for cause in e.chain() {
-                            write!(&mut error, "\n  Cause: {cause}").unwrap();
-                        }
-                        error
-                    })
-                })
-            }
-            Err(e) => Err((
-                if let Error::WithPath { path, .. } = e {
-                    Some(path.clone())
-                } else {
-                    None
-                },
-                e.io_error()
-                    .map_or_else(|| e.to_string(), io::Error::to_string),
-            )),
-        };
-
-        Some(result.unwrap_or_else(|(path, message)| {
-            if let Some(path) = &path {
-                let settings = resolver.resolve(path);
-                if settings.linter.rules.enabled(Rule::IOError) {
-                    let dummy =
-                        SourceFileBuilder::new(path.to_string_lossy().as_ref(), "").finish();
-
-                    Diagnostics::new(
-                        vec![Message::from_diagnostic(
-                            OldDiagnostic::new(IOError { message }, TextRange::default(), &dummy),
-                            None,
-                        )],
-                        FxHashMap::default(),
-                    )
-                } else {
-                    warn!(
-                        "{}{}{} {message}",
-                        "Failed to lint ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    );
-                    Diagnostics::default()
-                }
-            } else {
-                warn!("{} {message}", "Encountered error:".bold());
-                Diagnostics::default()
-            }
-        }))
-    });
-
-    // Aggregate the diagnostics of all checked files and count the checked files.
-    // This can't be a regular for loop because we use `par_iter`.
-    let (mut all_diagnostics, checked_files) = diagnostics_per_file
-        .fold(
-            || (Diagnostics::default(), 0u64),
-            |(all_diagnostics, checked_files), file_diagnostics| {
-                (all_diagnostics + file_diagnostics, checked_files + 1)
-            },
-        )
-        .reduce(
-            || (Diagnostics::default(), 0u64),
-            |a, b| (a.0 + b.0, a.1 + b.1),
-        );
-
-    all_diagnostics.messages.sort();
-
-    // Store the caches.
-    caches.persist()?;
-
-    let duration = start.elapsed();
-    debug!("Checked {checked_files:?} files in: {duration:?}");
-
-    Ok(all_diagnostics)
-}
-
-/// Wraps [`lint_path`](crate::diagnostics::lint_path) in a [`catch_unwind`](std::panic::catch_unwind) and emits
-/// a diagnostic if the linting the file panics.
-fn lint_path(
-    path: &Path,
-    package: Option<PackageRoot<'_>>,
-    settings: &LinterSettings,
-    cache: Option<&Cache>,
-    noqa: flags::Noqa,
-    fix_mode: flags::FixMode,
-    unsafe_fixes: UnsafeFixes,
-) -> Result<Diagnostics> {
-    let result = catch_unwind(|| {
-        crate::diagnostics::lint_path(path, package, settings, cache, noqa, fix_mode, unsafe_fixes)
-    });
-
-    match result {
-        Ok(inner) => inner,
-        Err(error) => {
-            let message = r"This indicates a bug in Ruff. If you could open an issue at:
-
-    https://github.com/astral-sh/ruff/issues/new?title=%5BLinter%20panic%5D
-
-...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
-";
-
-            error!(
-                "{}{}{} {message}\n{error}",
-                "Panicked while linting ".bold(),
-                fs::relativize_path(path).bold(),
-                ":".bold()
-            );
-
-            Ok(Diagnostics::default())
-        }
-    }
-}
-
-#[cfg(test)]
-#[cfg(unix)]
-mod test {
-    use std::fs;
-    use std::os::unix::fs::OpenOptionsExt;
-
-    use anyhow::Result;
-    use rustc_hash::FxHashMap;
-    use tempfile::TempDir;
-
-    use ruff_linter::message::{Emitter, EmitterContext, TextEmitter};
-    use ruff_linter::registry::Rule;
-    use ruff_linter::settings::types::UnsafeFixes;
-    use ruff_linter::settings::{LinterSettings, flags};
-    use ruff_workspace::Settings;
-    use ruff_workspace::resolver::{PyprojectConfig, PyprojectDiscoveryStrategy};
-
-    use crate::args::ConfigArguments;
-
-    use super::check;
-
-    /// We check that regular python files, pyproject.toml and jupyter notebooks all handle io
-    /// errors gracefully
-    #[test]
-    fn unreadable_files() -> Result<()> {
-        let path = "E902.py";
-        let rule_code = Rule::IOError;
-
-        // Create inaccessible files
-        let tempdir = TempDir::new()?;
-        let pyproject_toml = tempdir.path().join("pyproject.toml");
-        let python_file = tempdir.path().join("code.py");
-        let notebook = tempdir.path().join("notebook.ipynb");
-        for file in [&pyproject_toml, &python_file, &notebook] {
-            fs::OpenOptions::new()
-                .create(true)
-                .truncate(true)
-                .write(true)
-                .mode(0o000)
-                .open(file)?;
-        }
-
-        // Configure
-        let snapshot = format!("{}_{}", rule_code.noqa_code(), path);
-        // invalid pyproject.toml is not active by default
-        let settings = Settings {
-            linter: LinterSettings::for_rules(vec![rule_code, Rule::InvalidPyprojectToml]),
-            ..Settings::default()
-        };
-        let pyproject_config =
-            PyprojectConfig::new(PyprojectDiscoveryStrategy::Fixed, settings, None);
-
-        // Run
-        let diagnostics = check(
-            &[tempdir.path().to_path_buf()],
-            &pyproject_config,
-            &ConfigArguments::default(),
-            flags::Cache::Disabled,
-            flags::Noqa::Disabled,
-            flags::FixMode::Generate,
-            UnsafeFixes::Enabled,
-        )
-        .unwrap();
-        let mut output = Vec::new();
-
-        TextEmitter::default()
-            .with_show_fix_status(true)
-            .emit(
-                &mut output,
-                &diagnostics.messages,
-                &EmitterContext::new(&FxHashMap::default()),
-            )
-            .unwrap();
-
-        let messages = String::from_utf8(output).unwrap();
-
-        insta::with_settings!({
-            omit_expression => true,
-            filters => vec![
-                // The tempdir is always different (and platform dependent)
-                (tempdir.path().to_str().unwrap(), "/home/ferris/project"),
-            ]
-        }, {
-            insta::assert_snapshot!(snapshot, messages);
-        });
-        Ok(())
-    }
-}
--- a/crates/ruff/src/commands/check_stdin.rs
+++ b/crates/ruff/src/commands/check_stdin.rs
@@ -1,57 +0,0 @@
-use std::path::Path;
-
-use anyhow::Result;
-use ruff_linter::package::PackageRoot;
-use ruff_linter::packaging;
-use ruff_linter::settings::flags;
-use ruff_workspace::resolver::{PyprojectConfig, Resolver, match_exclusion, python_file_at_path};
-
-use crate::args::ConfigArguments;
-use crate::diagnostics::{Diagnostics, lint_stdin};
-use crate::stdin::{parrot_stdin, read_from_stdin};
-
-/// Run the linter over a single file, read from `stdin`.
-pub(crate) fn check_stdin(
-    filename: Option<&Path>,
-    pyproject_config: &PyprojectConfig,
-    overrides: &ConfigArguments,
-    noqa: flags::Noqa,
-    fix_mode: flags::FixMode,
-) -> Result<Diagnostics> {
-    let mut resolver = Resolver::new(pyproject_config);
-
-    if resolver.force_exclude() {
-        if let Some(filename) = filename {
-            if !python_file_at_path(filename, &mut resolver, overrides)? {
-                if fix_mode.is_apply() {
-                    parrot_stdin()?;
-                }
-                return Ok(Diagnostics::default());
-            }
-
-            if filename.file_name().is_some_and(|name| {
-                match_exclusion(filename, name, &resolver.base_settings().linter.exclude)
-            }) {
-                if fix_mode.is_apply() {
-                    parrot_stdin()?;
-                }
-                return Ok(Diagnostics::default());
-            }
-        }
-    }
-    let stdin = read_from_stdin()?;
-    let package_root = filename.and_then(Path::parent).and_then(|path| {
-        packaging::detect_package_root(path, &resolver.base_settings().linter.namespace_packages)
-            .map(PackageRoot::root)
-    });
-    let mut diagnostics = lint_stdin(
-        filename,
-        package_root,
-        stdin,
-        resolver.base_settings(),
-        noqa,
-        fix_mode,
-    )?;
-    diagnostics.messages.sort_unstable();
-    Ok(diagnostics)
-}
--- a/crates/ruff/src/commands/clean.rs
+++ b/crates/ruff/src/commands/clean.rs
@@ -1,34 +0,0 @@
-use std::fs::remove_dir_all;
-use std::io::{self, BufWriter, Write};
-
-use anyhow::Result;
-use colored::Colorize;
-use path_absolutize::path_dedot;
-use walkdir::WalkDir;
-
-use ruff_cache::CACHE_DIR_NAME;
-use ruff_linter::fs;
-use ruff_linter::logging::LogLevel;
-
-/// Clear any caches in the current directory or any subdirectories.
-pub(crate) fn clean(level: LogLevel) -> Result<()> {
-    let mut stderr = BufWriter::new(io::stderr().lock());
-    for entry in WalkDir::new(&*path_dedot::CWD)
-        .into_iter()
-        .filter_map(Result::ok)
-        .filter(|entry| entry.file_type().is_dir())
-    {
-        let cache = entry.path().join(CACHE_DIR_NAME);
-        if cache.is_dir() {
-            if level >= LogLevel::Default {
-                writeln!(
-                    stderr,
-                    "Removing cache at: {}",
-                    fs::relativize_path(&cache).bold()
-                )?;
-            }
-            remove_dir_all(&cache)?;
-        }
-    }
-    Ok(())
-}
--- a/crates/ruff/src/commands/completions/config.rs
+++ b/crates/ruff/src/commands/completions/config.rs
@@ -1,156 +0,0 @@
-use clap::builder::{PossibleValue, TypedValueParser, ValueParserFactory};
-use itertools::Itertools;
-use std::str::FromStr;
-
-use ruff_options_metadata::{OptionField, OptionSet, OptionsMetadata, Visit};
-use ruff_workspace::options::Options;
-
-#[derive(Default)]
-struct CollectOptionsVisitor {
-    values: Vec<(String, String)>,
-    parents: Vec<String>,
-}
-
-impl IntoIterator for CollectOptionsVisitor {
-    type Item = (String, String);
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.values.into_iter()
-    }
-}
-
-impl Visit for CollectOptionsVisitor {
-    fn record_set(&mut self, name: &str, group: OptionSet) {
-        let fully_qualified_name = self
-            .parents
-            .iter()
-            .map(String::as_str)
-            .chain(std::iter::once(name))
-            .collect::<Vec<_>>()
-            .join(".");
-
-        // Only add the set to completion list if it has it's own documentation.
-        self.values.push((
-            fully_qualified_name,
-            group.documentation().unwrap_or("").to_owned(),
-        ));
-
-        self.parents.push(name.to_owned());
-        group.record(self);
-        self.parents.pop();
-    }
-
-    fn record_field(&mut self, name: &str, field: OptionField) {
-        let fqn = self
-            .parents
-            .iter()
-            .map(String::as_str)
-            .chain(std::iter::once(name))
-            .collect::<Vec<_>>()
-            .join(".");
-
-        self.values.push((fqn, field.doc.to_owned()));
-    }
-}
-
-/// Opaque type used solely to enable tab completions
-/// for `ruff option [OPTION]` command.
-#[derive(Clone, Debug)]
-pub struct OptionString(String);
-
-impl From<String> for OptionString {
-    fn from(s: String) -> Self {
-        OptionString(s)
-    }
-}
-
-impl From<OptionString> for String {
-    fn from(value: OptionString) -> Self {
-        value.0
-    }
-}
-
-impl From<&str> for OptionString {
-    fn from(s: &str) -> Self {
-        OptionString(s.to_string())
-    }
-}
-
-impl std::ops::Deref for OptionString {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl FromStr for OptionString {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Options::metadata()
-            .has(s)
-            .then(|| OptionString(s.to_owned()))
-            .ok_or(())
-    }
-}
-
-#[derive(Clone)]
-pub struct OptionStringParser;
-
-impl ValueParserFactory for OptionString {
-    type Parser = OptionStringParser;
-
-    fn value_parser() -> Self::Parser {
-        OptionStringParser
-    }
-}
-
-impl TypedValueParser for OptionStringParser {
-    type Value = OptionString;
-
-    fn parse_ref(
-        &self,
-        cmd: &clap::Command,
-        arg: Option<&clap::Arg>,
-        value: &std::ffi::OsStr,
-    ) -> Result<Self::Value, clap::Error> {
-        let value = value
-            .to_str()
-            .ok_or_else(|| clap::Error::new(clap::error::ErrorKind::InvalidUtf8))?;
-
-        value.parse().map_err(|()| {
-            let mut error = clap::Error::new(clap::error::ErrorKind::ValueValidation).with_cmd(cmd);
-            if let Some(arg) = arg {
-                error.insert(
-                    clap::error::ContextKind::InvalidArg,
-                    clap::error::ContextValue::String(arg.to_string()),
-                );
-            }
-            error.insert(
-                clap::error::ContextKind::InvalidValue,
-                clap::error::ContextValue::String(value.to_string()),
-            );
-            error
-        })
-    }
-
-    fn possible_values(&self) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>> {
-        let mut visitor = CollectOptionsVisitor::default();
-        Options::metadata().record(&mut visitor);
-
-        Some(Box::new(visitor.into_iter().map(|(name, doc)| {
-            let first_paragraph = doc
-                .lines()
-                .take_while(|line| !line.trim_end().is_empty())
-                // Replace double quotes with single quotes,to avoid clap's lack of escaping
-                // when creating zsh completions. This has no security implications, as it only
-                // affects the help string, which is never executed
-                .map(|s| s.replace('"', "'"))
-                .join(" ");
-
-            PossibleValue::new(name).help(first_paragraph)
-        })))
-    }
-}
--- a/crates/ruff/src/commands/completions/mod.rs
+++ b/crates/ruff/src/commands/completions/mod.rs
@@ -1 +0,0 @@
-pub(crate) mod config;
--- a/crates/ruff/src/commands/config.rs
+++ b/crates/ruff/src/commands/config.rs
@@ -1,39 +0,0 @@
-use anyhow::{Result, anyhow};
-
-use crate::args::HelpFormat;
-
-use ruff_options_metadata::OptionsMetadata;
-use ruff_workspace::options::Options;
-
-#[expect(clippy::print_stdout)]
-pub(crate) fn config(key: Option<&str>, format: HelpFormat) -> Result<()> {
-    match key {
-        None => {
-            let metadata = Options::metadata();
-            match format {
-                HelpFormat::Text => {
-                    println!("{metadata}");
-                }
-
-                HelpFormat::Json => {
-                    println!("{}", &serde_json::to_string_pretty(&metadata)?);
-                }
-            }
-        }
-        Some(key) => match Options::metadata().find(key) {
-            None => {
-                return Err(anyhow!("Unknown option: {key}"));
-            }
-            Some(entry) => match format {
-                HelpFormat::Text => {
-                    print!("{entry}");
-                }
-
-                HelpFormat::Json => {
-                    println!("{}", &serde_json::to_string_pretty(&entry)?);
-                }
-            },
-        },
-    }
-    Ok(())
-}
--- a/crates/ruff/src/commands/format.rs
+++ b/crates/ruff/src/commands/format.rs
@@ -1,965 +0,0 @@
-use std::fmt::{Display, Formatter};
-use std::fs::File;
-use std::io;
-use std::io::{Write, stderr, stdout};
-use std::path::{Path, PathBuf};
-use std::time::Instant;
-
-use anyhow::Result;
-use colored::Colorize;
-use itertools::Itertools;
-use log::{error, warn};
-use rayon::iter::Either::{Left, Right};
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use ruff_python_parser::ParseError;
-use rustc_hash::FxHashSet;
-use thiserror::Error;
-use tracing::debug;
-
-use ruff_db::panic::{PanicError, catch_unwind};
-use ruff_diagnostics::SourceMap;
-use ruff_linter::fs;
-use ruff_linter::logging::{DisplayParseError, LogLevel};
-use ruff_linter::package::PackageRoot;
-use ruff_linter::registry::Rule;
-use ruff_linter::rules::flake8_quotes::settings::Quote;
-use ruff_linter::source_kind::{SourceError, SourceKind};
-use ruff_linter::warn_user_once;
-use ruff_python_ast::{PySourceType, SourceType};
-use ruff_python_formatter::{FormatModuleError, QuoteStyle, format_module_source, format_range};
-use ruff_source_file::LineIndex;
-use ruff_text_size::{TextLen, TextRange, TextSize};
-use ruff_workspace::FormatterSettings;
-use ruff_workspace::resolver::{ResolvedFile, Resolver, match_exclusion, python_files_in_path};
-
-use crate::args::{ConfigArguments, FormatArguments, FormatRange};
-use crate::cache::{Cache, FileCacheKey, PackageCacheMap, PackageCaches};
-use crate::resolve::resolve;
-use crate::{ExitStatus, resolve_default_files};
-
-#[derive(Debug, Copy, Clone, is_macro::Is)]
-pub(crate) enum FormatMode {
-    /// Write the formatted contents back to the file.
-    Write,
-    /// Check if the file is formatted, but do not write the formatted contents back.
-    Check,
-    /// Check if the file is formatted, show a diff if not.
-    Diff,
-}
-
-impl FormatMode {
-    pub(crate) fn from_cli(cli: &FormatArguments) -> Self {
-        if cli.diff {
-            FormatMode::Diff
-        } else if cli.check {
-            FormatMode::Check
-        } else {
-            FormatMode::Write
-        }
-    }
-}
-
-/// Format a set of files, and return the exit status.
-pub(crate) fn format(
-    cli: FormatArguments,
-    config_arguments: &ConfigArguments,
-) -> Result<ExitStatus> {
-    let pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
-    let mode = FormatMode::from_cli(&cli);
-    let files = resolve_default_files(cli.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(ExitStatus::Success);
-    }
-
-    if cli.range.is_some() && paths.len() > 1 {
-        return Err(anyhow::anyhow!(
-            "The `--range` option is only supported when formatting a single file but the specified paths resolve to {} files.",
-            paths.len()
-        ));
-    }
-
-    warn_incompatible_formatter_settings(&resolver);
-
-    // Discover the package root for each Python file.
-    let package_roots = resolver.package_roots(
-        &paths
-            .iter()
-            .flatten()
-            .map(ResolvedFile::path)
-            .collect::<Vec<_>>(),
-    );
-
-    let caches = if cli.no_cache {
-        None
-    } else {
-        // `--no-cache` doesn't respect code changes, and so is often confusing during
-        // development.
-        #[cfg(debug_assertions)]
-        crate::warn_user!("Detected debug build without --no-cache.");
-
-        Some(PackageCacheMap::init(&package_roots, &resolver))
-    };
-
-    let start = Instant::now();
-    let (results, mut errors): (Vec<_>, Vec<_>) = paths
-        .par_iter()
-        .filter_map(|entry| {
-            match entry {
-                Ok(resolved_file) => {
-                    let path = resolved_file.path();
-                    let settings = resolver.resolve(path);
-
-                    let source_type = match settings.formatter.extension.get(path) {
-                        None => match SourceType::from(path) {
-                            SourceType::Python(source_type) => source_type,
-                            SourceType::Toml(_) => {
-                                // Ignore any non-Python files.
-                                return None;
-                            }
-                        },
-                        Some(language) => PySourceType::from(language),
-                    };
-
-                    // Ignore files that are excluded from formatting
-                    if (settings.file_resolver.force_exclude || !resolved_file.is_root())
-                        && match_exclusion(
-                            path,
-                            resolved_file.file_name(),
-                            &settings.formatter.exclude,
-                        )
-                    {
-                        return None;
-                    }
-
-                    let package = path
-                        .parent()
-                        .and_then(|parent| package_roots.get(parent).copied())
-                        .flatten();
-                    let cache_root = package
-                        .map(PackageRoot::path)
-                        .unwrap_or_else(|| path.parent().unwrap_or(path));
-                    let cache = caches.get(cache_root);
-
-                    Some(
-                        match catch_unwind(|| {
-                            format_path(
-                                path,
-                                &settings.formatter,
-                                source_type,
-                                mode,
-                                cli.range,
-                                cache,
-                            )
-                        }) {
-                            Ok(inner) => inner.map(|result| FormatPathResult {
-                                path: resolved_file.path().to_path_buf(),
-                                result,
-                            }),
-                            Err(error) => Err(FormatCommandError::Panic(
-                                Some(resolved_file.path().to_path_buf()),
-                                Box::new(error),
-                            )),
-                        },
-                    )
-                }
-                Err(err) => Some(Err(FormatCommandError::Ignore(err.clone()))),
-            }
-        })
-        .partition_map(|result| match result {
-            Ok(diagnostic) => Left(diagnostic),
-            Err(err) => Right(err),
-        });
-    let duration = start.elapsed();
-
-    debug!(
-        "Formatted {} files in {:.2?}",
-        results.len() + errors.len(),
-        duration
-    );
-
-    // Store the caches.
-    caches.persist()?;
-
-    // Report on any errors.
-    errors.sort_unstable_by(|a, b| a.path().cmp(&b.path()));
-
-    for error in &errors {
-        error!("{error}");
-    }
-
-    let results = FormatResults::new(results.as_slice(), mode);
-    match mode {
-        FormatMode::Write => {}
-        FormatMode::Check => {
-            results.write_changed(&mut stdout().lock())?;
-        }
-        FormatMode::Diff => {
-            results.write_diff(&mut stdout().lock())?;
-        }
-    }
-
-    // Report on the formatting changes.
-    if config_arguments.log_level >= LogLevel::Default {
-        if mode.is_diff() {
-            // Allow piping the diff to e.g. a file by writing the summary to stderr
-            results.write_summary(&mut stderr().lock())?;
-        } else {
-            results.write_summary(&mut stdout().lock())?;
-        }
-    }
-
-    match mode {
-        FormatMode::Write => {
-            if errors.is_empty() {
-                if cli.exit_non_zero_on_format && results.any_formatted() {
-                    Ok(ExitStatus::Failure)
-                } else {
-                    Ok(ExitStatus::Success)
-                }
-            } else {
-                Ok(ExitStatus::Error)
-            }
-        }
-        FormatMode::Check | FormatMode::Diff => {
-            if errors.is_empty() {
-                if results.any_formatted() {
-                    Ok(ExitStatus::Failure)
-                } else {
-                    Ok(ExitStatus::Success)
-                }
-            } else {
-                Ok(ExitStatus::Error)
-            }
-        }
-    }
-}
-
-/// Format the file at the given [`Path`].
-#[tracing::instrument(level = "debug", skip_all, fields(path = %path.display()))]
-pub(crate) fn format_path(
-    path: &Path,
-    settings: &FormatterSettings,
-    source_type: PySourceType,
-    mode: FormatMode,
-    range: Option<FormatRange>,
-    cache: Option<&Cache>,
-) -> Result<FormatResult, FormatCommandError> {
-    if let Some(cache) = cache {
-        let relative_path = cache
-            .relative_path(path)
-            .expect("wrong package cache for file");
-
-        if let Ok(cache_key) = FileCacheKey::from_path(path) {
-            if cache.is_formatted(relative_path, &cache_key) {
-                return Ok(FormatResult::Unchanged);
-            }
-        }
-    }
-
-    // Extract the sources from the file.
-    let unformatted = match SourceKind::from_path(path, source_type) {
-        Ok(Some(source_kind)) => source_kind,
-        // Non-Python Jupyter notebook.
-        Ok(None) => return Ok(FormatResult::Skipped),
-        Err(err) => {
-            return Err(FormatCommandError::Read(Some(path.to_path_buf()), err));
-        }
-    };
-
-    // Don't write back to the cache if formatting a range.
-    let cache = cache.filter(|_| range.is_none());
-
-    // Format the source.
-    let format_result = match format_source(&unformatted, source_type, Some(path), settings, range)?
-    {
-        FormattedSource::Formatted(formatted) => match mode {
-            FormatMode::Write => {
-                let mut writer = File::create(path).map_err(|err| {
-                    FormatCommandError::Write(Some(path.to_path_buf()), err.into())
-                })?;
-                formatted
-                    .write(&mut writer)
-                    .map_err(|err| FormatCommandError::Write(Some(path.to_path_buf()), err))?;
-
-                if let Some(cache) = cache {
-                    if let Ok(cache_key) = FileCacheKey::from_path(path) {
-                        let relative_path = cache
-                            .relative_path(path)
-                            .expect("wrong package cache for file");
-                        cache.set_formatted(relative_path.to_path_buf(), &cache_key);
-                    }
-                }
-
-                FormatResult::Formatted
-            }
-            FormatMode::Check => FormatResult::Formatted,
-            FormatMode::Diff => FormatResult::Diff {
-                unformatted,
-                formatted,
-            },
-        },
-        FormattedSource::Unchanged => {
-            if let Some(cache) = cache {
-                if let Ok(cache_key) = FileCacheKey::from_path(path) {
-                    let relative_path = cache
-                        .relative_path(path)
-                        .expect("wrong package cache for file");
-                    cache.set_formatted(relative_path.to_path_buf(), &cache_key);
-                }
-            }
-
-            FormatResult::Unchanged
-        }
-    };
-
-    Ok(format_result)
-}
-
-#[derive(Debug)]
-pub(crate) enum FormattedSource {
-    /// The source was formatted, and the [`SourceKind`] contains the transformed source code.
-    Formatted(SourceKind),
-    /// The source was unchanged.
-    Unchanged,
-}
-
-impl From<FormattedSource> for FormatResult {
-    fn from(value: FormattedSource) -> Self {
-        match value {
-            FormattedSource::Formatted(_) => FormatResult::Formatted,
-            FormattedSource::Unchanged => FormatResult::Unchanged,
-        }
-    }
-}
-
-/// Format a [`SourceKind`], returning the transformed [`SourceKind`], or `None` if the source was
-/// unchanged.
-pub(crate) fn format_source(
-    source_kind: &SourceKind,
-    source_type: PySourceType,
-    path: Option<&Path>,
-    settings: &FormatterSettings,
-    range: Option<FormatRange>,
-) -> Result<FormattedSource, FormatCommandError> {
-    match &source_kind {
-        SourceKind::Python(unformatted) => {
-            let options = settings.to_format_options(source_type, unformatted, path);
-
-            let formatted = if let Some(range) = range {
-                let line_index = LineIndex::from_source_text(unformatted);
-                let byte_range = range.to_text_range(unformatted, &line_index);
-                format_range(unformatted, byte_range, options).map(|formatted_range| {
-                    let mut formatted = unformatted.to_string();
-                    formatted.replace_range(
-                        std::ops::Range::<usize>::from(formatted_range.source_range()),
-                        formatted_range.as_code(),
-                    );
-
-                    formatted
-                })
-            } else {
-                // Using `Printed::into_code` requires adding `ruff_formatter` as a direct dependency, and I suspect that Rust can optimize the closure away regardless.
-                #[expect(clippy::redundant_closure_for_method_calls)]
-                format_module_source(unformatted, options).map(|formatted| formatted.into_code())
-            };
-
-            let formatted = formatted.map_err(|err| {
-                if let FormatModuleError::ParseError(err) = err {
-                    DisplayParseError::from_source_kind(
-                        err,
-                        path.map(Path::to_path_buf),
-                        source_kind,
-                    )
-                    .into()
-                } else {
-                    FormatCommandError::Format(path.map(Path::to_path_buf), err)
-                }
-            })?;
-
-            if formatted.len() == unformatted.len() && formatted == *unformatted {
-                Ok(FormattedSource::Unchanged)
-            } else {
-                Ok(FormattedSource::Formatted(SourceKind::Python(formatted)))
-            }
-        }
-        SourceKind::IpyNotebook(notebook) => {
-            if !notebook.is_python_notebook() {
-                return Ok(FormattedSource::Unchanged);
-            }
-
-            if range.is_some() {
-                return Err(FormatCommandError::RangeFormatNotebook(
-                    path.map(Path::to_path_buf),
-                ));
-            }
-
-            let options = settings.to_format_options(source_type, notebook.source_code(), path);
-
-            let mut output: Option<String> = None;
-            let mut last: Option<TextSize> = None;
-            let mut source_map = SourceMap::default();
-
-            // Format each cell individually.
-            for (start, end) in notebook.cell_offsets().iter().tuple_windows::<(_, _)>() {
-                let range = TextRange::new(*start, *end);
-                let unformatted = &notebook.source_code()[range];
-
-                // Format the cell.
-                let formatted =
-                    format_module_source(unformatted, options.clone()).map_err(|err| {
-                        if let FormatModuleError::ParseError(err) = err {
-                            // Offset the error by the start of the cell
-                            DisplayParseError::from_source_kind(
-                                ParseError {
-                                    error: err.error,
-                                    location: err.location.checked_add(*start).unwrap(),
-                                },
-                                path.map(Path::to_path_buf),
-                                source_kind,
-                            )
-                            .into()
-                        } else {
-                            FormatCommandError::Format(path.map(Path::to_path_buf), err)
-                        }
-                    })?;
-
-                // If the cell is unchanged, skip it.
-                let formatted = formatted.as_code();
-                if formatted.len() == unformatted.len() && formatted == unformatted {
-                    continue;
-                }
-
-                // If this is the first newly-formatted cell, initialize the output.
-                let output = output
-                    .get_or_insert_with(|| String::with_capacity(notebook.source_code().len()));
-
-                // Add all contents from `last` to the current cell.
-                let slice = &notebook.source_code()
-                    [TextRange::new(last.unwrap_or_default(), range.start())];
-                output.push_str(slice);
-
-                // Add the start source marker for the cell.
-                source_map.push_marker(*start, output.text_len());
-
-                // Add the cell itself.
-                output.push_str(formatted);
-
-                // Add the end source marker for the added cell.
-                source_map.push_marker(*end, output.text_len());
-
-                // Track that the cell was formatted.
-                last = Some(*end);
-            }
-
-            // If the file was unchanged, return `None`.
-            let (Some(mut output), Some(last)) = (output, last) else {
-                return Ok(FormattedSource::Unchanged);
-            };
-
-            // Add the remaining content.
-            let slice = &notebook.source_code()[usize::from(last)..];
-            output.push_str(slice);
-
-            // Update the notebook.
-            let mut formatted = notebook.clone();
-            formatted.update(&source_map, output);
-
-            Ok(FormattedSource::Formatted(SourceKind::IpyNotebook(
-                formatted,
-            )))
-        }
-    }
-}
-
-/// The result of an individual formatting operation.
-#[derive(Debug, Clone, is_macro::Is)]
-pub(crate) enum FormatResult {
-    /// The file was formatted.
-    Formatted,
-
-    /// The file was formatted, [`SourceKind`] contains the formatted code
-    Diff {
-        unformatted: SourceKind,
-        formatted: SourceKind,
-    },
-
-    /// The file was unchanged, as the formatted contents matched the existing contents.
-    Unchanged,
-
-    /// Skipped formatting because its an unsupported file format
-    Skipped,
-}
-
-/// The coupling of a [`FormatResult`] with the path of the file that was analyzed.
-#[derive(Debug)]
-struct FormatPathResult {
-    path: PathBuf,
-    result: FormatResult,
-}
-
-/// The results of formatting a set of files
-#[derive(Debug)]
-struct FormatResults<'a> {
-    /// The individual formatting results.
-    results: &'a [FormatPathResult],
-    /// The format mode that was used.
-    mode: FormatMode,
-}
-
-impl<'a> FormatResults<'a> {
-    fn new(results: &'a [FormatPathResult], mode: FormatMode) -> Self {
-        Self { results, mode }
-    }
-
-    /// Returns `true` if any of the files require formatting.
-    fn any_formatted(&self) -> bool {
-        self.results.iter().any(|result| match result.result {
-            FormatResult::Formatted | FormatResult::Diff { .. } => true,
-            FormatResult::Unchanged | FormatResult::Skipped => false,
-        })
-    }
-
-    /// Write a diff of the formatting changes to the given writer.
-    fn write_diff(&self, f: &mut impl Write) -> io::Result<()> {
-        for (path, unformatted, formatted) in self
-            .results
-            .iter()
-            .filter_map(|result| {
-                if let FormatResult::Diff {
-                    unformatted,
-                    formatted,
-                } = &result.result
-                {
-                    Some((result.path.as_path(), unformatted, formatted))
-                } else {
-                    None
-                }
-            })
-            .sorted_unstable_by_key(|(path, _, _)| *path)
-        {
-            write!(f, "{}", unformatted.diff(formatted, Some(path)).unwrap())?;
-        }
-
-        Ok(())
-    }
-
-    /// Write a list of the files that would be changed to the given writer.
-    fn write_changed(&self, f: &mut impl Write) -> io::Result<()> {
-        for path in self
-            .results
-            .iter()
-            .filter_map(|result| {
-                if result.result.is_formatted() {
-                    Some(result.path.as_path())
-                } else {
-                    None
-                }
-            })
-            .sorted_unstable()
-        {
-            writeln!(f, "Would reformat: {}", fs::relativize_path(path).bold())?;
-        }
-
-        Ok(())
-    }
-
-    /// Write a summary of the formatting results to the given writer.
-    fn write_summary(&self, f: &mut impl Write) -> io::Result<()> {
-        // Compute the number of changed and unchanged files.
-        let mut changed = 0u32;
-        let mut unchanged = 0u32;
-        for result in self.results {
-            match &result.result {
-                FormatResult::Formatted => {
-                    changed += 1;
-                }
-                FormatResult::Unchanged => unchanged += 1,
-                FormatResult::Diff { .. } => {
-                    changed += 1;
-                }
-                FormatResult::Skipped => {}
-            }
-        }
-
-        // Write out a summary of the formatting results.
-        if changed > 0 && unchanged > 0 {
-            writeln!(
-                f,
-                "{} file{} {}, {} file{} {}",
-                changed,
-                if changed == 1 { "" } else { "s" },
-                match self.mode {
-                    FormatMode::Write => "reformatted",
-                    FormatMode::Check | FormatMode::Diff => "would be reformatted",
-                },
-                unchanged,
-                if unchanged == 1 { "" } else { "s" },
-                match self.mode {
-                    FormatMode::Write => "left unchanged",
-                    FormatMode::Check | FormatMode::Diff => "already formatted",
-                },
-            )
-        } else if changed > 0 {
-            writeln!(
-                f,
-                "{} file{} {}",
-                changed,
-                if changed == 1 { "" } else { "s" },
-                match self.mode {
-                    FormatMode::Write => "reformatted",
-                    FormatMode::Check | FormatMode::Diff => "would be reformatted",
-                }
-            )
-        } else if unchanged > 0 {
-            writeln!(
-                f,
-                "{} file{} {}",
-                unchanged,
-                if unchanged == 1 { "" } else { "s" },
-                match self.mode {
-                    FormatMode::Write => "left unchanged",
-                    FormatMode::Check | FormatMode::Diff => "already formatted",
-                },
-            )
-        } else {
-            Ok(())
-        }
-    }
-}
-
-/// An error that can occur while formatting a set of files.
-#[derive(Error, Debug)]
-pub(crate) enum FormatCommandError {
-    Ignore(#[from] ignore::Error),
-    Parse(#[from] DisplayParseError),
-    Panic(Option<PathBuf>, Box<PanicError>),
-    Read(Option<PathBuf>, SourceError),
-    Format(Option<PathBuf>, FormatModuleError),
-    Write(Option<PathBuf>, SourceError),
-    Diff(Option<PathBuf>, io::Error),
-    RangeFormatNotebook(Option<PathBuf>),
-}
-
-impl FormatCommandError {
-    fn path(&self) -> Option<&Path> {
-        match self {
-            Self::Ignore(err) => {
-                if let ignore::Error::WithPath { path, .. } = err {
-                    Some(path.as_path())
-                } else {
-                    None
-                }
-            }
-            Self::Parse(err) => err.path(),
-            Self::Panic(path, _)
-            | Self::Read(path, _)
-            | Self::Format(path, _)
-            | Self::Write(path, _)
-            | Self::Diff(path, _)
-            | Self::RangeFormatNotebook(path) => path.as_deref(),
-        }
-    }
-}
-
-impl Display for FormatCommandError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Ignore(err) => {
-                if let ignore::Error::WithPath { path, .. } = err {
-                    write!(
-                        f,
-                        "{}{}{} {}",
-                        "Failed to format ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold(),
-                        err.io_error()
-                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
-                    )
-                } else {
-                    write!(
-                        f,
-                        "{header} {error}",
-                        header = "Encountered error:".bold(),
-                        error = err
-                            .io_error()
-                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
-                    )
-                }
-            }
-            Self::Parse(err) => {
-                write!(f, "{err}")
-            }
-            Self::Read(path, err) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {err}",
-                        "Failed to read ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(f, "{header} {err}", header = "Failed to read:".bold())
-                }
-            }
-            Self::Write(path, err) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {err}",
-                        "Failed to write ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(f, "{header} {err}", header = "Failed to write:".bold())
-                }
-            }
-            Self::Format(path, err) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {err}",
-                        "Failed to format ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(f, "{header} {err}", header = "Failed to format:".bold())
-                }
-            }
-            Self::Diff(path, err) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {err}",
-                        "Failed to generate diff for ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(
-                        f,
-                        "{header} {err}",
-                        header = "Failed to generate diff:".bold(),
-                    )
-                }
-            }
-            Self::RangeFormatNotebook(path) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{header}{path}{colon} Range formatting isn't supported for notebooks.",
-                        header = "Failed to format ".bold(),
-                        path = fs::relativize_path(path).bold(),
-                        colon = ":".bold()
-                    )
-                } else {
-                    write!(
-                        f,
-                        "{header} Range formatting isn't supported for notebooks",
-                        header = "Failed to format:".bold()
-                    )
-                }
-            }
-            Self::Panic(path, err) => {
-                let message = r"This indicates a bug in Ruff. If you could open an issue at:
-
-    https://github.com/astral-sh/ruff/issues/new?title=%5BFormatter%20panic%5D
-
-...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
-";
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {message}\n{err}",
-                        "Panicked while formatting ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(
-                        f,
-                        "{} {message}\n{err}",
-                        "Panicked while formatting.".bold()
-                    )
-                }
-            }
-        }
-    }
-}
-
-pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
-    // First, collect all rules that are incompatible regardless of the linter-specific settings.
-    let mut incompatible_rules = FxHashSet::default();
-    for setting in resolver.settings() {
-        for rule in [
-            // Flags missing trailing commas when all arguments are on its own line:
-            // ```python
-            // def args(
-            //     aaaaaaaa, bbbbbbbbb, cccccccccc, ddddddddd, eeeeeeee, ffffff, gggggggggggg, hhhh
-            // ):
-            //     pass
-            // ```
-            Rule::MissingTrailingComma,
-            // The formatter always removes blank lines before the docstring.
-            Rule::IncorrectBlankLineBeforeClass,
-        ] {
-            if setting.linter.rules.enabled(rule) {
-                incompatible_rules.insert(rule);
-            }
-        }
-    }
-
-    if !incompatible_rules.is_empty() {
-        let mut rule_names: Vec<_> = incompatible_rules
-            .into_iter()
-            .map(|rule| format!("`{}`", rule.noqa_code()))
-            .collect();
-        rule_names.sort();
-        if let [rule] = rule_names.as_slice() {
-            warn_user_once!(
-                "The following rule may cause conflicts when used with the formatter: {rule}. To avoid unexpected behavior, we recommend disabling this rule, either by removing it from the `lint.select` or `lint.extend-select` configuration, or adding it to the `lint.ignore` configuration."
-            );
-        } else {
-            warn_user_once!(
-                "The following rules may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `lint.select` or `lint.extend-select` configuration, or adding them to the `lint.ignore` configuration.",
-                rule_names.join(", ")
-            );
-        }
-    }
-
-    // Next, validate settings-specific incompatibilities.
-    for setting in resolver.settings() {
-        // Validate all rules that rely on tab styles.
-        if setting.linter.rules.enabled(Rule::TabIndentation)
-            && setting.formatter.indent_style.is_tab()
-        {
-            warn_user_once!(
-                "The `format.indent-style=\"tab\"` option is incompatible with `W191`, which lints against all uses of tabs. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `\"space\"`."
-            );
-        }
-
-        if !setting
-            .linter
-            .rules
-            .enabled(Rule::SingleLineImplicitStringConcatenation)
-            && setting
-                .linter
-                .rules
-                .enabled(Rule::MultiLineImplicitStringConcatenation)
-            && !setting.linter.flake8_implicit_str_concat.allow_multiline
-        {
-            warn_user_once!(
-                "The `lint.flake8-implicit-str-concat.allow-multiline = false` option is incompatible with the formatter unless `ISC001` is enabled. We recommend enabling `ISC001` or setting `allow-multiline=true`."
-            );
-        }
-
-        // Validate all rules that rely on tab styles.
-        if setting.linter.rules.enabled(Rule::DocstringTabIndentation)
-            && setting.formatter.indent_style.is_tab()
-        {
-            warn_user_once!(
-                "The `format.indent-style=\"tab\"` option is incompatible with `D206`, with requires space-based indentation. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `\"space\"`."
-            );
-        }
-
-        // Validate all rules that rely on custom indent widths.
-        if setting.linter.rules.any_enabled(&[
-            Rule::IndentationWithInvalidMultiple,
-            Rule::IndentationWithInvalidMultipleComment,
-        ]) && setting.formatter.indent_width.value() != 4
-        {
-            warn_user_once!(
-                "The `format.indent-width` option with a value other than 4 is incompatible with `E111` and `E114`. We recommend disabling these rules when using the formatter, which enforces a consistent indentation width. Alternatively, set the `format.indent-width` option to `4`."
-            );
-        }
-
-        // Validate all rules that rely on quote styles.
-        if setting
-            .linter
-            .rules
-            .any_enabled(&[Rule::BadQuotesInlineString, Rule::AvoidableEscapedQuote])
-        {
-            match (
-                setting.linter.flake8_quotes.inline_quotes,
-                setting.formatter.quote_style,
-            ) {
-                (Quote::Double, QuoteStyle::Single) => {
-                    warn_user_once!(
-                        "The `flake8-quotes.inline-quotes=\"double\"` option is incompatible with the formatter's `format.quote-style=\"single\"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `\"single\"` or `\"double\"`."
-                    );
-                }
-                (Quote::Single, QuoteStyle::Double) => {
-                    warn_user_once!(
-                        "The `flake8-quotes.inline-quotes=\"single\"` option is incompatible with the formatter's `format.quote-style=\"double\"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `\"single\"` or `\"double\"`."
-                    );
-                }
-                _ => {}
-            }
-        }
-
-        if setting.linter.rules.enabled(Rule::BadQuotesMultilineString)
-            && setting.linter.flake8_quotes.multiline_quotes == Quote::Single
-            && matches!(
-                setting.formatter.quote_style,
-                QuoteStyle::Single | QuoteStyle::Double
-            )
-        {
-            warn_user_once!(
-                "The `flake8-quotes.multiline-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q001` when using the formatter, which enforces double quotes for multiline strings. Alternatively, set the `flake8-quotes.multiline-quotes` option to `\"double\"`.`"
-            );
-        }
-
-        if setting.linter.rules.enabled(Rule::BadQuotesDocstring)
-            && setting.linter.flake8_quotes.docstring_quotes == Quote::Single
-            && matches!(
-                setting.formatter.quote_style,
-                QuoteStyle::Single | QuoteStyle::Double
-            )
-        {
-            warn_user_once!(
-                "The `flake8-quotes.docstring-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q002` when using the formatter, which enforces double quotes for docstrings. Alternatively, set the `flake8-quotes.docstring-quotes` option to `\"double\"`.`"
-            );
-        }
-
-        // Validate all isort settings.
-        if setting.linter.rules.enabled(Rule::UnsortedImports) {
-            // The formatter removes empty lines if the value is larger than 2 but always inserts a empty line after imports.
-            // Two empty lines are okay because `isort` only uses this setting for top-level imports (not in nested blocks).
-            if !matches!(setting.linter.isort.lines_after_imports, 1 | 2 | -1) {
-                warn_user_once!(
-                    "The isort option `isort.lines-after-imports` with a value other than `-1`, `1` or `2` is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `2`, `1`, or `-1` (default)."
-                );
-            }
-
-            // Values larger than two get reduced to one line by the formatter if the import is in a nested block.
-            if setting.linter.isort.lines_between_types > 1 {
-                warn_user_once!(
-                    "The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default)."
-                );
-            }
-
-            // isort inserts a trailing comma which the formatter preserves, but only if `skip-magic-trailing-comma` isn't false.
-            // This isn't relevant when using `force-single-line`, since isort will never include a trailing comma in that case.
-            if setting.formatter.magic_trailing_comma.is_ignore()
-                && !setting.linter.isort.force_single_line
-            {
-                if setting.linter.isort.force_wrap_aliases {
-                    warn_user_once!(
-                        "The isort option `isort.force-wrap-aliases` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.force-wrap-aliases=false` or `format.skip-magic-trailing-comma=false`."
-                    );
-                }
-
-                if setting.linter.isort.split_on_trailing_comma {
-                    warn_user_once!(
-                        "The isort option `isort.split-on-trailing-comma` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.split-on-trailing-comma=false` or `format.skip-magic-trailing-comma=false`."
-                    );
-                }
-            }
-        }
-    }
-}
--- a/crates/ruff/src/commands/format_stdin.rs
+++ b/crates/ruff/src/commands/format_stdin.rs
@@ -1,142 +0,0 @@
-use std::io::stdout;
-use std::path::Path;
-
-use anyhow::Result;
-use log::error;
-
-use ruff_linter::source_kind::SourceKind;
-use ruff_python_ast::{PySourceType, SourceType};
-use ruff_workspace::FormatterSettings;
-use ruff_workspace::resolver::{Resolver, match_exclusion, python_file_at_path};
-
-use crate::ExitStatus;
-use crate::args::{ConfigArguments, FormatArguments, FormatRange};
-use crate::commands::format::{
-    FormatCommandError, FormatMode, FormatResult, FormattedSource, format_source,
-    warn_incompatible_formatter_settings,
-};
-use crate::resolve::resolve;
-use crate::stdin::{parrot_stdin, read_from_stdin};
-
-/// Run the formatter over a single file, read from `stdin`.
-pub(crate) fn format_stdin(
-    cli: &FormatArguments,
-    config_arguments: &ConfigArguments,
-) -> Result<ExitStatus> {
-    let pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
-
-    let mut resolver = Resolver::new(&pyproject_config);
-    warn_incompatible_formatter_settings(&resolver);
-
-    let mode = FormatMode::from_cli(cli);
-
-    if resolver.force_exclude() {
-        if let Some(filename) = cli.stdin_filename.as_deref() {
-            if !python_file_at_path(filename, &mut resolver, config_arguments)? {
-                if mode.is_write() {
-                    parrot_stdin()?;
-                }
-                return Ok(ExitStatus::Success);
-            }
-
-            if filename.file_name().is_some_and(|name| {
-                match_exclusion(filename, name, &resolver.base_settings().formatter.exclude)
-            }) {
-                if mode.is_write() {
-                    parrot_stdin()?;
-                }
-                return Ok(ExitStatus::Success);
-            }
-        }
-    }
-
-    let path = cli.stdin_filename.as_deref();
-    let settings = &resolver.base_settings().formatter;
-
-    let source_type = match path.and_then(|path| settings.extension.get(path)) {
-        None => match path.map(SourceType::from).unwrap_or_default() {
-            SourceType::Python(source_type) => source_type,
-            SourceType::Toml(_) => {
-                if mode.is_write() {
-                    parrot_stdin()?;
-                }
-                return Ok(ExitStatus::Success);
-            }
-        },
-        Some(language) => PySourceType::from(language),
-    };
-
-    // Format the file.
-    match format_source_code(path, cli.range, settings, source_type, mode) {
-        Ok(result) => match mode {
-            FormatMode::Write => Ok(ExitStatus::Success),
-            FormatMode::Check | FormatMode::Diff => {
-                if result.is_formatted() {
-                    Ok(ExitStatus::Failure)
-                } else {
-                    Ok(ExitStatus::Success)
-                }
-            }
-        },
-        Err(err) => {
-            error!("{err}");
-            Ok(ExitStatus::Error)
-        }
-    }
-}
-
-/// Format source code read from `stdin`.
-fn format_source_code(
-    path: Option<&Path>,
-    range: Option<FormatRange>,
-    settings: &FormatterSettings,
-    source_type: PySourceType,
-    mode: FormatMode,
-) -> Result<FormatResult, FormatCommandError> {
-    // Read the source from stdin.
-    let source_code = read_from_stdin()
-        .map_err(|err| FormatCommandError::Read(path.map(Path::to_path_buf), err.into()))?;
-
-    let source_kind = match SourceKind::from_source_code(source_code, source_type) {
-        Ok(Some(source_kind)) => source_kind,
-        Ok(None) => return Ok(FormatResult::Unchanged),
-        Err(err) => {
-            return Err(FormatCommandError::Read(path.map(Path::to_path_buf), err));
-        }
-    };
-
-    // Format the source.
-    let formatted = format_source(&source_kind, source_type, path, settings, range)?;
-
-    match &formatted {
-        FormattedSource::Formatted(formatted) => match mode {
-            FormatMode::Write => {
-                let mut writer = stdout().lock();
-                formatted
-                    .write(&mut writer)
-                    .map_err(|err| FormatCommandError::Write(path.map(Path::to_path_buf), err))?;
-            }
-            FormatMode::Check => {}
-            FormatMode::Diff => {
-                use std::io::Write;
-                write!(
-                    &mut stdout().lock(),
-                    "{}",
-                    source_kind.diff(formatted, path).unwrap()
-                )
-                .map_err(|err| FormatCommandError::Diff(path.map(Path::to_path_buf), err))?;
-            }
-        },
-        FormattedSource::Unchanged => {
-            // Write to stdout regardless of whether the source was formatted
-            if mode.is_write() {
-                let mut writer = stdout().lock();
-                source_kind
-                    .write(&mut writer)
-                    .map_err(|err| FormatCommandError::Write(path.map(Path::to_path_buf), err))?;
-            }
-        }
-    }
-
-    Ok(FormatResult::from(formatted))
-}
--- a/crates/ruff/src/commands/linter.rs
+++ b/crates/ruff/src/commands/linter.rs
@@ -1,71 +0,0 @@
-use std::fmt::Write;
-use std::io;
-use std::io::BufWriter;
-
-use anyhow::Result;
-use itertools::Itertools;
-use serde::Serialize;
-use strum::IntoEnumIterator;
-
-use ruff_linter::registry::{Linter, RuleNamespace};
-
-use crate::args::HelpFormat;
-
-#[derive(Serialize)]
-struct LinterInfo {
-    prefix: &'static str,
-    name: &'static str,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    categories: Option<Vec<LinterCategoryInfo>>,
-}
-
-#[derive(Serialize)]
-struct LinterCategoryInfo {
-    prefix: &'static str,
-    name: &'static str,
-}
-
-pub(crate) fn linter(format: HelpFormat) -> Result<()> {
-    let mut stdout = BufWriter::new(io::stdout().lock());
-    let mut output = String::new();
-
-    match format {
-        HelpFormat::Text => {
-            for linter in Linter::iter() {
-                let prefix = match linter.common_prefix() {
-                    "" => linter
-                        .upstream_categories()
-                        .unwrap()
-                        .iter()
-                        .map(|c| c.prefix)
-                        .join("/"),
-                    prefix => prefix.to_string(),
-                };
-                writeln!(output, "{:>4} {}", prefix, linter.name()).unwrap();
-            }
-        }
-
-        HelpFormat::Json => {
-            let linters: Vec<_> = Linter::iter()
-                .map(|linter_info| LinterInfo {
-                    prefix: linter_info.common_prefix(),
-                    name: linter_info.name(),
-                    categories: linter_info.upstream_categories().map(|cats| {
-                        cats.iter()
-                            .map(|c| LinterCategoryInfo {
-                                prefix: c.prefix,
-                                name: c.category,
-                            })
-                            .collect()
-                    }),
-                })
-                .collect();
-            output.push_str(&serde_json::to_string_pretty(&linters)?);
-            output.push('\n');
-        }
-    }
-
-    io::Write::write_fmt(&mut stdout, format_args!("{output}"))?;
-
-    Ok(())
-}
--- a/crates/ruff/src/commands/mod.rs
+++ b/crates/ruff/src/commands/mod.rs
@@ -1,16 +0,0 @@
-pub(crate) mod completions;
-
-pub(crate) mod add_noqa;
-pub(crate) mod analyze_graph;
-pub(crate) mod check;
-pub(crate) mod check_stdin;
-pub(crate) mod clean;
-pub(crate) mod config;
-pub(crate) mod format;
-pub(crate) mod format_stdin;
-pub(crate) mod linter;
-pub(crate) mod rule;
-pub(crate) mod server;
-pub(crate) mod show_files;
-pub(crate) mod show_settings;
-pub(crate) mod version;
--- a/crates/ruff/src/commands/rule.rs
+++ b/crates/ruff/src/commands/rule.rs
@@ -1,124 +0,0 @@
-use std::fmt::Write as _;
-use std::io::{self, BufWriter, Write};
-
-use anyhow::Result;
-use serde::ser::SerializeSeq;
-use serde::{Serialize, Serializer};
-use strum::IntoEnumIterator;
-
-use ruff_linter::FixAvailability;
-use ruff_linter::registry::{Linter, Rule, RuleNamespace};
-
-use crate::args::HelpFormat;
-
-#[derive(Serialize)]
-struct Explanation<'a> {
-    name: &'a str,
-    code: String,
-    linter: &'a str,
-    summary: &'a str,
-    message_formats: &'a [&'a str],
-    fix: String,
-    #[expect(clippy::struct_field_names)]
-    explanation: Option<&'a str>,
-    preview: bool,
-}
-
-impl<'a> Explanation<'a> {
-    fn from_rule(rule: &'a Rule) -> Self {
-        let code = rule.noqa_code().to_string();
-        let (linter, _) = Linter::parse_code(&code).unwrap();
-        let fix = rule.fixable().to_string();
-        Self {
-            name: rule.as_ref(),
-            code,
-            linter: linter.name(),
-            summary: rule.message_formats()[0],
-            message_formats: rule.message_formats(),
-            fix,
-            explanation: rule.explanation(),
-            preview: rule.is_preview(),
-        }
-    }
-}
-
-fn format_rule_text(rule: Rule) -> String {
-    let mut output = String::new();
-    let _ = write!(&mut output, "# {} ({})", rule.as_ref(), rule.noqa_code());
-    output.push('\n');
-    output.push('\n');
-
-    let (linter, _) = Linter::parse_code(&rule.noqa_code().to_string()).unwrap();
-    let _ = write!(
-        &mut output,
-        "Derived from the **{}** linter.",
-        linter.name()
-    );
-    output.push('\n');
-    output.push('\n');
-
-    let fix_availability = rule.fixable();
-    if matches!(
-        fix_availability,
-        FixAvailability::Always | FixAvailability::Sometimes
-    ) {
-        output.push_str(&fix_availability.to_string());
-        output.push('\n');
-        output.push('\n');
-    }
-
-    if rule.is_preview() {
-        output.push_str(
-            r"This rule is in preview and is not stable. The `--preview` flag is required for use.",
-        );
-        output.push('\n');
-        output.push('\n');
-    }
-
-    if let Some(explanation) = rule.explanation() {
-        output.push_str(explanation.trim());
-    } else {
-        output.push_str("Message formats:");
-        for format in rule.message_formats() {
-            output.push('\n');
-            let _ = write!(&mut output, "* {format}");
-        }
-    }
-    output
-}
-
-/// Explain a `Rule` to the user.
-pub(crate) fn rule(rule: Rule, format: HelpFormat) -> Result<()> {
-    let mut stdout = BufWriter::new(io::stdout().lock());
-    match format {
-        HelpFormat::Text => {
-            writeln!(stdout, "{}", format_rule_text(rule))?;
-        }
-        HelpFormat::Json => {
-            serde_json::to_writer_pretty(stdout, &Explanation::from_rule(&rule))?;
-        }
-    }
-    Ok(())
-}
-
-/// Explain all rules to the user.
-pub(crate) fn rules(format: HelpFormat) -> Result<()> {
-    let mut stdout = BufWriter::new(io::stdout().lock());
-    match format {
-        HelpFormat::Text => {
-            for rule in Rule::iter() {
-                writeln!(stdout, "{}", format_rule_text(rule))?;
-                writeln!(stdout)?;
-            }
-        }
-        HelpFormat::Json => {
-            let mut serializer = serde_json::Serializer::pretty(stdout);
-            let mut seq = serializer.serialize_seq(None)?;
-            for rule in Rule::iter() {
-                seq.serialize_element(&Explanation::from_rule(&rule))?;
-            }
-            seq.end()?;
-        }
-    }
-    Ok(())
-}
--- a/crates/ruff/src/commands/server.rs
+++ b/crates/ruff/src/commands/server.rs
@@ -1,14 +0,0 @@
-use std::num::NonZeroUsize;
-
-use crate::ExitStatus;
-use anyhow::Result;
-use ruff_server::Server;
-
-pub(crate) fn run_server(
-    worker_threads: NonZeroUsize,
-    preview: Option<bool>,
-) -> Result<ExitStatus> {
-    let server = Server::new(worker_threads, preview)?;
-
-    server.run().map(|()| ExitStatus::Success)
-}
--- a/crates/ruff/src/commands/show_files.rs
+++ b/crates/ruff/src/commands/show_files.rs
@@ -1,38 +0,0 @@
-use std::io::Write;
-use std::path::PathBuf;
-
-use anyhow::Result;
-use itertools::Itertools;
-
-use ruff_linter::warn_user_once;
-use ruff_workspace::resolver::{PyprojectConfig, ResolvedFile, python_files_in_path};
-
-use crate::args::ConfigArguments;
-
-/// Show the list of files to be checked based on current settings.
-pub(crate) fn show_files(
-    files: &[PathBuf],
-    pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
-    writer: &mut impl Write,
-) -> Result<()> {
-    // Collect all files in the hierarchy.
-    let (paths, _resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
-
-    if paths.is_empty() {
-        warn_user_once!("No Python files found under the given path(s)");
-        return Ok(());
-    }
-
-    // Print the list of files.
-    for path in paths
-        .into_iter()
-        .flatten()
-        .map(ResolvedFile::into_path)
-        .sorted_unstable()
-    {
-        writeln!(writer, "{}", path.to_string_lossy())?;
-    }
-
-    Ok(())
-}
--- a/crates/ruff/src/commands/show_settings.rs
+++ b/crates/ruff/src/commands/show_settings.rs
@@ -1,41 +0,0 @@
-use std::io::Write;
-use std::path::PathBuf;
-
-use anyhow::{Result, bail};
-use itertools::Itertools;
-
-use ruff_workspace::resolver::{PyprojectConfig, ResolvedFile, python_files_in_path};
-
-use crate::args::ConfigArguments;
-
-/// Print the user-facing configuration settings.
-pub(crate) fn show_settings(
-    files: &[PathBuf],
-    pyproject_config: &PyprojectConfig,
-    config_arguments: &ConfigArguments,
-    writer: &mut impl Write,
-) -> Result<()> {
-    // Collect all files in the hierarchy.
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
-
-    // Print the list of files.
-    let Some(path) = paths
-        .into_iter()
-        .flatten()
-        .map(ResolvedFile::into_path)
-        .sorted_unstable()
-        .next()
-    else {
-        bail!("No files found under the given path");
-    };
-
-    let settings = resolver.resolve(&path);
-
-    writeln!(writer, "Resolved settings for: \"{}\"", path.display())?;
-    if let Some(settings_path) = pyproject_config.path.as_ref() {
-        writeln!(writer, "Settings path: \"{}\"", settings_path.display())?;
-    }
-    write!(writer, "{settings}")?;
-
-    Ok(())
-}
--- a/crates/ruff/src/commands/snapshots/ruffcommandschecktestE902_E902.py.snap
+++ b/crates/ruff/src/commands/snapshots/ruffcommandschecktestE902_E902.py.snap
@@ -1,7 +0,0 @@
---
-source: crates/ruff/src/commands/check.rs
---
-/home/ferris/project/code.py:1:1: E902 Permission denied (os error 13)
-/home/ferris/project/notebook.ipynb:1:1: E902 Permission denied (os error 13)
-/home/ferris/project/pyproject.toml:1:1: E902 Permission denied (os error 13)
-
--- a/crates/ruff/src/commands/version.rs
+++ b/crates/ruff/src/commands/version.rs
@@ -1,21 +0,0 @@
-use std::io::{self, BufWriter, Write};
-
-use anyhow::Result;
-
-use crate::args::HelpFormat;
-
-/// Display version information
-pub(crate) fn version(output_format: HelpFormat) -> Result<()> {
-    let mut stdout = BufWriter::new(io::stdout().lock());
-    let version_info = crate::version::version();
-
-    match output_format {
-        HelpFormat::Text => {
-            writeln!(stdout, "ruff {}", &version_info)?;
-        }
-        HelpFormat::Json => {
-            serde_json::to_writer_pretty(stdout, &version_info)?;
-        }
-    }
-    Ok(())
-}
--- a/crates/ruff/src/diagnostics.rs
+++ b/crates/ruff/src/diagnostics.rs
@@ -1,511 +0,0 @@
-#![cfg_attr(target_family = "wasm", allow(dead_code))]
-
-use std::borrow::Cow;
-use std::fs::File;
-use std::io;
-use std::io::Write;
-use std::ops::{Add, AddAssign};
-use std::path::Path;
-
-use anyhow::{Context, Result};
-use colored::Colorize;
-use log::{debug, warn};
-use rustc_hash::FxHashMap;
-
-use ruff_linter::OldDiagnostic;
-use ruff_linter::codes::Rule;
-use ruff_linter::linter::{FixTable, FixerResult, LinterResult, ParseSource, lint_fix, lint_only};
-use ruff_linter::message::Message;
-use ruff_linter::package::PackageRoot;
-use ruff_linter::pyproject_toml::lint_pyproject_toml;
-use ruff_linter::settings::types::UnsafeFixes;
-use ruff_linter::settings::{LinterSettings, flags};
-use ruff_linter::source_kind::{SourceError, SourceKind};
-use ruff_linter::{IOError, fs};
-use ruff_notebook::{Notebook, NotebookError, NotebookIndex};
-use ruff_python_ast::{PySourceType, SourceType, TomlSourceType};
-use ruff_source_file::SourceFileBuilder;
-use ruff_text_size::TextRange;
-use ruff_workspace::Settings;
-
-use crate::cache::{Cache, FileCacheKey, LintCacheData};
-
-#[derive(Debug, Default, PartialEq)]
-pub(crate) struct Diagnostics {
-    pub(crate) messages: Vec<Message>,
-    pub(crate) fixed: FixMap,
-    pub(crate) notebook_indexes: FxHashMap<String, NotebookIndex>,
-}
-
-impl Diagnostics {
-    pub(crate) fn new(
-        messages: Vec<Message>,
-        notebook_indexes: FxHashMap<String, NotebookIndex>,
-    ) -> Self {
-        Self {
-            messages,
-            fixed: FixMap::default(),
-            notebook_indexes,
-        }
-    }
-
-    /// Generate [`Diagnostics`] based on a [`SourceError`].
-    pub(crate) fn from_source_error(
-        err: &SourceError,
-        path: Option<&Path>,
-        settings: &LinterSettings,
-    ) -> Self {
-        match err {
-            // IO errors.
-            SourceError::Io(_)
-            | SourceError::Notebook(NotebookError::Io(_) | NotebookError::Json(_)) => {
-                if settings.rules.enabled(Rule::IOError) {
-                    let name = path.map_or_else(|| "-".into(), Path::to_string_lossy);
-                    let source_file = SourceFileBuilder::new(name, "").finish();
-                    Self::new(
-                        vec![Message::from_diagnostic(
-                            OldDiagnostic::new(
-                                IOError {
-                                    message: err.to_string(),
-                                },
-                                TextRange::default(),
-                                &source_file,
-                            ),
-                            None,
-                        )],
-                        FxHashMap::default(),
-                    )
-                } else {
-                    match path {
-                        Some(path) => {
-                            warn!(
-                                "{}{}{} {err}",
-                                "Failed to lint ".bold(),
-                                fs::relativize_path(path).bold(),
-                                ":".bold()
-                            );
-                        }
-                        None => {
-                            warn!("{}{} {err}", "Failed to lint".bold(), ":".bold());
-                        }
-                    }
-
-                    Self::default()
-                }
-            }
-            // Syntax errors.
-            SourceError::Notebook(
-                NotebookError::InvalidJson(_)
-                | NotebookError::InvalidSchema(_)
-                | NotebookError::InvalidFormat(_),
-            ) => {
-                let name = path.map_or_else(|| "-".into(), Path::to_string_lossy);
-                let dummy = SourceFileBuilder::new(name, "").finish();
-                Self::new(
-                    vec![Message::syntax_error(err, TextRange::default(), dummy)],
-                    FxHashMap::default(),
-                )
-            }
-        }
-    }
-}
-
-impl Add for Diagnostics {
-    type Output = Diagnostics;
-
-    fn add(mut self, other: Self) -> Self::Output {
-        self += other;
-        self
-    }
-}
-
-impl AddAssign for Diagnostics {
-    fn add_assign(&mut self, other: Self) {
-        self.messages.extend(other.messages);
-        self.fixed += other.fixed;
-        self.notebook_indexes.extend(other.notebook_indexes);
-    }
-}
-
-/// A collection of fixes indexed by file path.
-#[derive(Debug, Default, PartialEq)]
-pub(crate) struct FixMap(FxHashMap<String, FixTable>);
-
-impl FixMap {
-    /// Returns `true` if there are no fixes in the map.
-    pub(crate) fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    /// Returns an iterator over the fixes in the map, along with the file path.
-    pub(crate) fn iter(&self) -> impl Iterator<Item = (&String, &FixTable)> {
-        self.0.iter()
-    }
-
-    /// Returns an iterator over the fixes in the map.
-    pub(crate) fn values(&self) -> impl Iterator<Item = &FixTable> {
-        self.0.values()
-    }
-}
-
-impl FromIterator<(String, FixTable)> for FixMap {
-    fn from_iter<T: IntoIterator<Item = (String, FixTable)>>(iter: T) -> Self {
-        Self(
-            iter.into_iter()
-                .filter(|(_, fixes)| !fixes.is_empty())
-                .collect(),
-        )
-    }
-}
-
-impl AddAssign for FixMap {
-    fn add_assign(&mut self, rhs: Self) {
-        for (filename, fixed) in rhs.0 {
-            if fixed.is_empty() {
-                continue;
-            }
-            let fixed_in_file = self.0.entry(filename).or_default();
-            for (rule, count) in fixed {
-                if count > 0 {
-                    *fixed_in_file.entry(rule).or_default() += count;
-                }
-            }
-        }
-    }
-}
-
-/// Lint the source code at the given `Path`.
-pub(crate) fn lint_path(
-    path: &Path,
-    package: Option<PackageRoot<'_>>,
-    settings: &LinterSettings,
-    cache: Option<&Cache>,
-    noqa: flags::Noqa,
-    fix_mode: flags::FixMode,
-    unsafe_fixes: UnsafeFixes,
-) -> Result<Diagnostics> {
-    // Check the cache.
-    let caching = match cache {
-        Some(cache) if noqa.is_enabled() => {
-            let relative_path = cache
-                .relative_path(path)
-                .expect("wrong package cache for file");
-
-            let cache_key = FileCacheKey::from_path(path).context("Failed to create cache key")?;
-            let cached_diagnostics = cache
-                .get(relative_path, &cache_key)
-                .and_then(|entry| entry.to_diagnostics(path));
-            if let Some(diagnostics) = cached_diagnostics {
-                // `FixMode::Generate` and `FixMode::Diff` rely on side-effects (writing to disk,
-                // and writing the diff to stdout, respectively). If a file has diagnostics, we
-                // need to avoid reading from and writing to the cache in these modes.
-                if match fix_mode {
-                    flags::FixMode::Generate => true,
-                    flags::FixMode::Apply | flags::FixMode::Diff => {
-                        diagnostics.messages.is_empty() && diagnostics.fixed.is_empty()
-                    }
-                } {
-                    return Ok(diagnostics);
-                }
-            }
-
-            // Stash the file metadata for later so when we update the cache it reflects the prerun
-            // information
-            Some((cache, relative_path, cache_key))
-        }
-        _ => None,
-    };
-
-    debug!("Checking: {}", path.display());
-
-    let source_type = match settings.extension.get(path).map(PySourceType::from) {
-        Some(source_type) => source_type,
-        None => match SourceType::from(path) {
-            SourceType::Toml(TomlSourceType::Pyproject) => {
-                let messages = if settings
-                    .rules
-                    .iter_enabled()
-                    .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
-                {
-                    let contents = match std::fs::read_to_string(path).map_err(SourceError::from) {
-                        Ok(contents) => contents,
-                        Err(err) => {
-                            return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
-                        }
-                    };
-                    let source_file =
-                        SourceFileBuilder::new(path.to_string_lossy(), contents).finish();
-                    lint_pyproject_toml(&source_file, settings)
-                } else {
-                    vec![]
-                };
-                return Ok(Diagnostics {
-                    messages,
-                    ..Diagnostics::default()
-                });
-            }
-            SourceType::Toml(_) => return Ok(Diagnostics::default()),
-            SourceType::Python(source_type) => source_type,
-        },
-    };
-
-    // Extract the sources from the file.
-    let source_kind = match SourceKind::from_path(path, source_type) {
-        Ok(Some(source_kind)) => source_kind,
-        Ok(None) => return Ok(Diagnostics::default()),
-        Err(err) => {
-            return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
-        }
-    };
-
-    // Lint the file.
-    let (result, transformed, fixed) =
-        if matches!(fix_mode, flags::FixMode::Apply | flags::FixMode::Diff) {
-            if let Ok(FixerResult {
-                result,
-                transformed,
-                fixed,
-            }) = lint_fix(
-                path,
-                package,
-                noqa,
-                unsafe_fixes,
-                settings,
-                &source_kind,
-                source_type,
-            ) {
-                if !fixed.is_empty() {
-                    match fix_mode {
-                        flags::FixMode::Apply => transformed.write(&mut File::create(path)?)?,
-                        flags::FixMode::Diff => {
-                            write!(
-                                &mut io::stdout().lock(),
-                                "{}",
-                                source_kind.diff(&transformed, Some(path)).unwrap()
-                            )?;
-                        }
-                        flags::FixMode::Generate => {}
-                    }
-                }
-                let transformed = if let Cow::Owned(transformed) = transformed {
-                    transformed
-                } else {
-                    source_kind
-                };
-                (result, transformed, fixed)
-            } else {
-                // If we fail to fix, lint the original source code.
-                let result = lint_only(
-                    path,
-                    package,
-                    settings,
-                    noqa,
-                    &source_kind,
-                    source_type,
-                    ParseSource::None,
-                );
-                let transformed = source_kind;
-                let fixed = FxHashMap::default();
-                (result, transformed, fixed)
-            }
-        } else {
-            let result = lint_only(
-                path,
-                package,
-                settings,
-                noqa,
-                &source_kind,
-                source_type,
-                ParseSource::None,
-            );
-            let transformed = source_kind;
-            let fixed = FxHashMap::default();
-            (result, transformed, fixed)
-        };
-
-    let has_error = result.has_syntax_errors();
-    let messages = result.messages;
-
-    if let Some((cache, relative_path, key)) = caching {
-        // We don't cache parsing errors.
-        if !has_error {
-            // `FixMode::Apply` and `FixMode::Diff` rely on side-effects (writing to disk,
-            // and writing the diff to stdout, respectively). If a file has diagnostics, we
-            // need to avoid reading from and writing to the cache in these modes.
-            if match fix_mode {
-                flags::FixMode::Generate => true,
-                flags::FixMode::Apply | flags::FixMode::Diff => {
-                    messages.is_empty() && fixed.is_empty()
-                }
-            } {
-                cache.update_lint(
-                    relative_path.to_owned(),
-                    &key,
-                    LintCacheData::from_messages(
-                        &messages,
-                        transformed.as_ipy_notebook().map(Notebook::index).cloned(),
-                    ),
-                );
-            }
-        }
-    }
-
-    let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = transformed {
-        FxHashMap::from_iter([(path.to_string_lossy().to_string(), notebook.into_index())])
-    } else {
-        FxHashMap::default()
-    };
-
-    Ok(Diagnostics {
-        messages,
-        fixed: FixMap::from_iter([(fs::relativize_path(path), fixed)]),
-        notebook_indexes,
-    })
-}
-
-/// Generate `Diagnostic`s from source code content derived from stdin.
-pub(crate) fn lint_stdin(
-    path: Option<&Path>,
-    package: Option<PackageRoot<'_>>,
-    contents: String,
-    settings: &Settings,
-    noqa: flags::Noqa,
-    fix_mode: flags::FixMode,
-) -> Result<Diagnostics> {
-    let source_type = match path.and_then(|path| settings.linter.extension.get(path)) {
-        None => match path.map(SourceType::from).unwrap_or_default() {
-            SourceType::Python(source_type) => source_type,
-
-            SourceType::Toml(source_type) if source_type.is_pyproject() => {
-                if !settings
-                    .linter
-                    .rules
-                    .iter_enabled()
-                    .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
-                {
-                    return Ok(Diagnostics::default());
-                }
-
-                let path = path.unwrap();
-                let source_file =
-                    SourceFileBuilder::new(path.to_string_lossy(), contents.clone()).finish();
-
-                match fix_mode {
-                    flags::FixMode::Diff | flags::FixMode::Generate => {}
-                    flags::FixMode::Apply => write!(&mut io::stdout().lock(), "{contents}")?,
-                }
-
-                return Ok(Diagnostics {
-                    messages: lint_pyproject_toml(&source_file, &settings.linter),
-                    fixed: FixMap::from_iter([(fs::relativize_path(path), FixTable::default())]),
-                    notebook_indexes: FxHashMap::default(),
-                });
-            }
-
-            SourceType::Toml(_) => return Ok(Diagnostics::default()),
-        },
-        Some(language) => PySourceType::from(language),
-    };
-
-    // Extract the sources from the file.
-    let source_kind = match SourceKind::from_source_code(contents, source_type) {
-        Ok(Some(source_kind)) => source_kind,
-        Ok(None) => return Ok(Diagnostics::default()),
-        Err(err) => {
-            return Ok(Diagnostics::from_source_error(&err, path, &settings.linter));
-        }
-    };
-
-    // Lint the inputs.
-    let (LinterResult { messages, .. }, transformed, fixed) =
-        if matches!(fix_mode, flags::FixMode::Apply | flags::FixMode::Diff) {
-            if let Ok(FixerResult {
-                result,
-                transformed,
-                fixed,
-            }) = lint_fix(
-                path.unwrap_or_else(|| Path::new("-")),
-                package,
-                noqa,
-                settings.unsafe_fixes,
-                &settings.linter,
-                &source_kind,
-                source_type,
-            ) {
-                match fix_mode {
-                    flags::FixMode::Apply => {
-                        // Write the contents to stdout, regardless of whether any errors were fixed.
-                        transformed.write(&mut io::stdout().lock())?;
-                    }
-                    flags::FixMode::Diff => {
-                        // But only write a diff if it's non-empty.
-                        if !fixed.is_empty() {
-                            write!(
-                                &mut io::stdout().lock(),
-                                "{}",
-                                source_kind.diff(&transformed, path).unwrap()
-                            )?;
-                        }
-                    }
-                    flags::FixMode::Generate => {}
-                }
-                let transformed = if let Cow::Owned(transformed) = transformed {
-                    transformed
-                } else {
-                    source_kind
-                };
-                (result, transformed, fixed)
-            } else {
-                // If we fail to fix, lint the original source code.
-                let result = lint_only(
-                    path.unwrap_or_else(|| Path::new("-")),
-                    package,
-                    &settings.linter,
-                    noqa,
-                    &source_kind,
-                    source_type,
-                    ParseSource::None,
-                );
-
-                // Write the contents to stdout anyway.
-                if fix_mode.is_apply() {
-                    source_kind.write(&mut io::stdout().lock())?;
-                }
-
-                let transformed = source_kind;
-                let fixed = FxHashMap::default();
-                (result, transformed, fixed)
-            }
-        } else {
-            let result = lint_only(
-                path.unwrap_or_else(|| Path::new("-")),
-                package,
-                &settings.linter,
-                noqa,
-                &source_kind,
-                source_type,
-                ParseSource::None,
-            );
-            let transformed = source_kind;
-            let fixed = FxHashMap::default();
-            (result, transformed, fixed)
-        };
-
-    let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = transformed {
-        FxHashMap::from_iter([(
-            path.map_or_else(|| "-".into(), |path| path.to_string_lossy().to_string()),
-            notebook.into_index(),
-        )])
-    } else {
-        FxHashMap::default()
-    };
-
-    Ok(Diagnostics {
-        messages,
-        fixed: FixMap::from_iter([(
-            fs::relativize_path(path.unwrap_or_else(|| Path::new("-"))),
-            fixed,
-        )]),
-        notebook_indexes,
-    })
-}
--- a/crates/ruff/src/lib.rs
+++ b/crates/ruff/src/lib.rs
@@ -1,606 +0,0 @@
-#![allow(clippy::print_stdout)]
-
-use std::fs::File;
-use std::io::{self, BufWriter, Write, stdout};
-use std::num::NonZeroUsize;
-use std::path::{Path, PathBuf};
-use std::process::ExitCode;
-use std::sync::mpsc::channel;
-
-use anyhow::Result;
-use clap::CommandFactory;
-use colored::Colorize;
-use log::warn;
-use notify::{RecursiveMode, Watcher, recommended_watcher};
-
-use args::{GlobalConfigArgs, ServerCommand};
-use ruff_linter::logging::{LogLevel, set_up_logging};
-use ruff_linter::settings::flags::FixMode;
-use ruff_linter::settings::types::OutputFormat;
-use ruff_linter::{fs, warn_user, warn_user_once};
-use ruff_workspace::Settings;
-
-use crate::args::{
-    AnalyzeCommand, AnalyzeGraphCommand, Args, CheckCommand, Command, FormatCommand,
-};
-use crate::printer::{Flags as PrinterFlags, Printer};
-
-pub mod args;
-mod cache;
-mod commands;
-mod diagnostics;
-mod printer;
-pub mod resolve;
-mod stdin;
-mod version;
-
-#[derive(Copy, Clone)]
-pub enum ExitStatus {
-    /// Linting was successful and there were no linting errors.
-    Success,
-    /// Linting was successful but there were linting errors.
-    Failure,
-    /// Linting failed.
-    Error,
-}
-
-impl From<ExitStatus> for ExitCode {
-    fn from(status: ExitStatus) -> Self {
-        match status {
-            ExitStatus::Success => ExitCode::from(0),
-            ExitStatus::Failure => ExitCode::from(1),
-            ExitStatus::Error => ExitCode::from(2),
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-enum ChangeKind {
-    Configuration,
-    SourceFile,
-}
-
-/// Return the [`ChangeKind`] based on the list of modified file paths.
-///
-/// Returns `None` if no relevant changes were detected.
-fn change_detected(event: &notify::Event) -> Option<ChangeKind> {
-    // If any `.toml` files were modified, return `ChangeKind::Configuration`. Otherwise, return
-    // `ChangeKind::SourceFile` if any `.py`, `.pyi`, `.pyw`, or `.ipynb` files were modified.
-    let mut source_file = false;
-
-    if event.kind.is_access() || event.kind.is_other() {
-        return None;
-    }
-
-    if event.need_rescan() {
-        return Some(ChangeKind::Configuration);
-    }
-    for path in &event.paths {
-        if let Some(suffix) = path.extension() {
-            match suffix.to_str() {
-                Some("toml") => {
-                    return Some(ChangeKind::Configuration);
-                }
-                Some("py" | "pyi" | "pyw" | "ipynb") => source_file = true,
-                _ => {}
-            }
-        }
-    }
-    if source_file {
-        return Some(ChangeKind::SourceFile);
-    }
-    None
-}
-
-/// Returns true if the command should read from standard input.
-fn is_stdin(files: &[PathBuf], stdin_filename: Option<&Path>) -> bool {
-    // If the user provided a `--stdin-filename`, always read from standard input.
-    if stdin_filename.is_some() {
-        if let Some(file) = files.iter().find(|file| file.as_path() != Path::new("-")) {
-            warn_user_once!(
-                "Ignoring file {} in favor of standard input.",
-                file.display()
-            );
-        }
-        return true;
-    }
-
-    let [file] = files else {
-        return false;
-    };
-    // If the user provided exactly `-`, read from standard input.
-    file == Path::new("-")
-}
-
-/// Returns the default set of files if none are provided, otherwise returns provided files.
-fn resolve_default_files(files: Vec<PathBuf>, is_stdin: bool) -> Vec<PathBuf> {
-    if files.is_empty() {
-        if is_stdin {
-            vec![Path::new("-").to_path_buf()]
-        } else {
-            vec![Path::new(".").to_path_buf()]
-        }
-    } else {
-        files
-    }
-}
-
-pub fn run(
-    Args {
-        command,
-        global_options,
-    }: Args,
-) -> Result<ExitStatus> {
-    {
-        let default_panic_hook = std::panic::take_hook();
-        std::panic::set_hook(Box::new(move |info| {
-            #[expect(clippy::print_stderr)]
-            {
-                eprintln!(
-                    r#"
-{}{} {} If you could open an issue at:
-
-    https://github.com/astral-sh/ruff/issues/new?title=%5BPanic%5D
-
-...quoting the executed command, along with the relevant file contents and `pyproject.toml` settings, we'd be very appreciative!
-"#,
-                    "error".red().bold(),
-                    ":".bold(),
-                    "Ruff crashed.".bold(),
-                );
-            }
-            default_panic_hook(info);
-        }));
-    }
-
-    // Don't set up logging for the server command, as it has its own logging setup
-    // and setting the global logger can only be done once.
-    if !matches!(command, Command::Server { .. }) {
-        set_up_logging(global_options.log_level())?;
-    }
-
-    match command {
-        Command::Version { output_format } => {
-            commands::version::version(output_format)?;
-            Ok(ExitStatus::Success)
-        }
-        Command::Rule {
-            rule,
-            all,
-            output_format,
-        } => {
-            if all {
-                commands::rule::rules(output_format)?;
-            }
-            if let Some(rule) = rule {
-                commands::rule::rule(rule, output_format)?;
-            }
-            Ok(ExitStatus::Success)
-        }
-        Command::Config {
-            option,
-            output_format,
-        } => {
-            commands::config::config(option.as_deref(), output_format)?;
-            Ok(ExitStatus::Success)
-        }
-        Command::Linter { output_format } => {
-            commands::linter::linter(output_format)?;
-            Ok(ExitStatus::Success)
-        }
-        Command::Clean => {
-            commands::clean::clean(global_options.log_level())?;
-            Ok(ExitStatus::Success)
-        }
-        Command::GenerateShellCompletion { shell } => {
-            shell.generate(&mut Args::command(), &mut stdout());
-            Ok(ExitStatus::Success)
-        }
-        Command::Check(args) => check(args, global_options),
-        Command::Format(args) => format(args, global_options),
-        Command::Server(args) => server(args),
-        Command::Analyze(AnalyzeCommand::Graph(args)) => analyze_graph(args, global_options),
-    }
-}
-
-fn format(args: FormatCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition(global_options)?;
-
-    if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
-        commands::format_stdin::format_stdin(&cli, &config_arguments)
-    } else {
-        commands::format::format(cli, &config_arguments)
-    }
-}
-
-fn analyze_graph(
-    args: AnalyzeGraphCommand,
-    global_options: GlobalConfigArgs,
-) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition(global_options)?;
-
-    commands::analyze_graph::analyze_graph(cli, &config_arguments)
-}
-
-fn server(args: ServerCommand) -> Result<ExitStatus> {
-    let four = NonZeroUsize::new(4).unwrap();
-
-    // by default, we set the number of worker threads to `num_cpus`, with a maximum of 4.
-    let worker_threads = std::thread::available_parallelism()
-        .unwrap_or(four)
-        .min(four);
-    commands::server::run_server(worker_threads, args.resolve_preview())
-}
-
-pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
-    let (cli, config_arguments) = args.partition(global_options)?;
-
-    // Construct the "default" settings. These are used when no `pyproject.toml`
-    // files are present, or files are injected from outside of the hierarchy.
-    let pyproject_config = resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
-
-    let mut writer: Box<dyn Write> = match cli.output_file {
-        Some(path) if !cli.watch => {
-            colored::control::set_override(false);
-            if let Some(parent) = path.parent() {
-                std::fs::create_dir_all(parent)?;
-            }
-            let file = File::create(path)?;
-            Box::new(BufWriter::new(file))
-        }
-        _ => Box::new(BufWriter::new(io::stdout())),
-    };
-    let stderr_writer = Box::new(BufWriter::new(io::stderr()));
-
-    let is_stdin = is_stdin(&cli.files, cli.stdin_filename.as_deref());
-    let files = resolve_default_files(cli.files, is_stdin);
-
-    if cli.show_settings {
-        commands::show_settings::show_settings(
-            &files,
-            &pyproject_config,
-            &config_arguments,
-            &mut writer,
-        )?;
-        return Ok(ExitStatus::Success);
-    }
-    if cli.show_files {
-        commands::show_files::show_files(
-            &files,
-            &pyproject_config,
-            &config_arguments,
-            &mut writer,
-        )?;
-        return Ok(ExitStatus::Success);
-    }
-
-    // Extract options that are included in `Settings`, but only apply at the top
-    // level.
-    let Settings {
-        fix,
-        fix_only,
-        unsafe_fixes,
-        output_format,
-        show_fixes,
-        ..
-    } = pyproject_config.settings;
-
-    // Fix rules are as follows:
-    // - By default, generate all fixes, but don't apply them to the filesystem.
-    // - If `--fix` or `--fix-only` is set, apply applicable fixes to the filesystem (or
-    //   print them to stdout, if we're reading from stdin).
-    // - If `--diff` or `--fix-only` are set, don't print any violations (only applicable fixes)
-    // - By default, applicable fixes only include [`Applicability::Automatic`], but if
-    //   `--unsafe-fixes` is set, then [`Applicability::Suggested`] fixes are included.
-
-    let fix_mode = if cli.diff {
-        FixMode::Diff
-    } else if fix || fix_only {
-        FixMode::Apply
-    } else {
-        FixMode::Generate
-    };
-
-    let cache = !cli.no_cache;
-    let noqa = !cli.ignore_noqa;
-    let mut printer_flags = PrinterFlags::empty();
-    if !(cli.diff || fix_only) {
-        printer_flags |= PrinterFlags::SHOW_VIOLATIONS;
-    }
-    if show_fixes {
-        printer_flags |= PrinterFlags::SHOW_FIX_SUMMARY;
-    }
-
-    #[cfg(debug_assertions)]
-    if cache {
-        // `--no-cache` doesn't respect code changes, and so is often confusing during
-        // development.
-        warn_user!("Detected debug build without --no-cache.");
-    }
-
-    if cli.add_noqa {
-        if !fix_mode.is_generate() {
-            warn_user!("--fix is incompatible with --add-noqa.");
-        }
-        let modifications =
-            commands::add_noqa::add_noqa(&files, &pyproject_config, &config_arguments)?;
-        if modifications > 0 && config_arguments.log_level >= LogLevel::Default {
-            let s = if modifications == 1 { "" } else { "s" };
-            #[expect(clippy::print_stderr)]
-            {
-                eprintln!("Added {modifications} noqa directive{s}.");
-            }
-        }
-        return Ok(ExitStatus::Success);
-    }
-
-    let printer = Printer::new(
-        output_format,
-        config_arguments.log_level,
-        fix_mode,
-        unsafe_fixes,
-        printer_flags,
-    );
-
-    // the settings should already be combined with the CLI overrides at this point
-    // TODO(jane): let's make this `PreviewMode`
-    // TODO: this should reference the global preview mode once https://github.com/astral-sh/ruff/issues/8232
-    //   is resolved.
-    let preview = pyproject_config.settings.linter.preview.is_enabled();
-
-    if cli.watch {
-        if output_format != OutputFormat::default() {
-            warn_user!(
-                "`--output-format {}` is always used in watch mode.",
-                OutputFormat::default()
-            );
-        }
-
-        // Configure the file watcher.
-        let (tx, rx) = channel();
-        let mut watcher = recommended_watcher(tx)?;
-        for file in &files {
-            watcher.watch(file, RecursiveMode::Recursive)?;
-        }
-        if let Some(file) = pyproject_config.path.as_ref() {
-            watcher.watch(file, RecursiveMode::Recursive)?;
-        }
-
-        // Perform an initial run instantly.
-        Printer::clear_screen()?;
-        printer.write_to_user("Starting linter in watch mode...\n");
-
-        let messages = commands::check::check(
-            &files,
-            &pyproject_config,
-            &config_arguments,
-            cache.into(),
-            noqa.into(),
-            fix_mode,
-            unsafe_fixes,
-        )?;
-        printer.write_continuously(&mut writer, &messages, preview)?;
-
-        // In watch mode, we may need to re-resolve the configuration.
-        // TODO(charlie): Re-compute other derivative values, like the `printer`.
-        let mut pyproject_config = pyproject_config;
-
-        loop {
-            match rx.recv() {
-                Ok(event) => {
-                    let Some(change_kind) = change_detected(&event?) else {
-                        continue;
-                    };
-
-                    if matches!(change_kind, ChangeKind::Configuration) {
-                        pyproject_config =
-                            resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
-                    }
-                    Printer::clear_screen()?;
-                    printer.write_to_user("File change detected...\n");
-
-                    let messages = commands::check::check(
-                        &files,
-                        &pyproject_config,
-                        &config_arguments,
-                        cache.into(),
-                        noqa.into(),
-                        fix_mode,
-                        unsafe_fixes,
-                    )?;
-                    printer.write_continuously(&mut writer, &messages, preview)?;
-                }
-                Err(err) => return Err(err.into()),
-            }
-        }
-    } else {
-        // Generate lint violations.
-        let diagnostics = if is_stdin {
-            commands::check_stdin::check_stdin(
-                cli.stdin_filename.map(fs::normalize_path).as_deref(),
-                &pyproject_config,
-                &config_arguments,
-                noqa.into(),
-                fix_mode,
-            )?
-        } else {
-            commands::check::check(
-                &files,
-                &pyproject_config,
-                &config_arguments,
-                cache.into(),
-                noqa.into(),
-                fix_mode,
-                unsafe_fixes,
-            )?
-        };
-
-        // Always try to print violations (though the printer itself may suppress output)
-        // If we're writing fixes via stdin, the transformed source code goes to the writer
-        // so send the summary to stderr instead
-        let mut summary_writer = if is_stdin && matches!(fix_mode, FixMode::Apply | FixMode::Diff) {
-            stderr_writer
-        } else {
-            writer
-        };
-        if cli.statistics {
-            printer.write_statistics(&diagnostics, &mut summary_writer)?;
-        } else {
-            printer.write_once(&diagnostics, &mut summary_writer)?;
-        }
-
-        if !cli.exit_zero {
-            if cli.diff {
-                // If we're printing a diff, we always want to exit non-zero if there are
-                // any fixable violations (since we've printed the diff, but not applied the
-                // fixes).
-                if !diagnostics.fixed.is_empty() {
-                    return Ok(ExitStatus::Failure);
-                }
-            } else if fix_only {
-                // If we're only fixing, we want to exit zero (since we've fixed all fixable
-                // violations), unless we're explicitly asked to exit non-zero on fix.
-                if cli.exit_non_zero_on_fix {
-                    if !diagnostics.fixed.is_empty() {
-                        return Ok(ExitStatus::Failure);
-                    }
-                }
-            } else {
-                // If we're running the linter (not just fixing), we want to exit non-zero if
-                // there are any violations, unless we're explicitly asked to exit zero on
-                // fix.
-                if cli.exit_non_zero_on_fix {
-                    if !diagnostics.fixed.is_empty() || !diagnostics.messages.is_empty() {
-                        return Ok(ExitStatus::Failure);
-                    }
-                } else {
-                    if !diagnostics.messages.is_empty() {
-                        return Ok(ExitStatus::Failure);
-                    }
-                }
-            }
-        }
-    }
-    Ok(ExitStatus::Success)
-}
-
-#[cfg(test)]
-mod test_file_change_detector {
-    use std::path::PathBuf;
-
-    use crate::{ChangeKind, change_detected};
-
-    #[test]
-    fn detect_correct_file_change() {
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/pyproject.toml"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("pyproject.toml"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp1/tmp2/tmp3/pyproject.toml"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/ruff.toml"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/.ruff.toml"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::SourceFile),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/rule.py"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::SourceFile),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/rule.pyi"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("pyproject.toml"),
-                    PathBuf::from("tmp/rule.py"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            Some(ChangeKind::Configuration),
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/rule.py"),
-                    PathBuf::from("pyproject.toml"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-        assert_eq!(
-            None,
-            change_detected(&notify::Event {
-                kind: notify::EventKind::Create(notify::event::CreateKind::File),
-                paths: vec![
-                    PathBuf::from("tmp/rule.js"),
-                    PathBuf::from("tmp/bin/ruff.rs"),
-                ],
-                attrs: notify::event::EventAttributes::default(),
-            }),
-        );
-    }
-}
--- a/crates/ruff/src/main.rs
+++ b/crates/ruff/src/main.rs
@@ -1,76 +0,0 @@
-use std::io::Write;
-use std::process::ExitCode;
-
-use clap::Parser;
-use colored::Colorize;
-
-use ruff::args::Args;
-use ruff::{ExitStatus, run};
-
-#[cfg(target_os = "windows")]
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-#[cfg(all(
-    not(target_os = "windows"),
-    not(target_os = "openbsd"),
-    not(target_os = "aix"),
-    not(target_os = "android"),
-    any(
-        target_arch = "x86_64",
-        target_arch = "aarch64",
-        target_arch = "powerpc64"
-    )
-))]
-#[global_allocator]
-static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
-
-pub fn main() -> ExitCode {
-    // Enabled ANSI colors on Windows 10.
-    #[cfg(windows)]
-    assert!(colored::control::set_virtual_terminal(true).is_ok());
-
-    // support FORCE_COLOR env var
-    if let Some(force_color) = std::env::var_os("FORCE_COLOR") {
-        if !force_color.is_empty() {
-            colored::control::set_override(true);
-        }
-    }
-
-    let args = wild::args_os();
-    let args = argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
-
-    let args = Args::parse_from(args);
-
-    match run(args) {
-        Ok(code) => code.into(),
-        Err(err) => {
-            {
-                // Exit "gracefully" on broken pipe errors.
-                //
-                // See: https://github.com/BurntSushi/ripgrep/blob/bf63fe8f258afc09bae6caa48f0ae35eaf115005/crates/core/main.rs#L47C1-L61C14
-                for cause in err.chain() {
-                    if let Some(ioerr) = cause.downcast_ref::<std::io::Error>() {
-                        if ioerr.kind() == std::io::ErrorKind::BrokenPipe {
-                            return ExitCode::from(0);
-                        }
-                    }
-                }
-
-                // Use `writeln` instead of `eprintln` to avoid panicking when the stderr pipe is broken.
-                let mut stderr = std::io::stderr().lock();
-
-                // This communicates that this isn't a linter error but ruff itself hard-errored for
-                // some reason (e.g. failed to resolve the configuration)
-                writeln!(stderr, "{}", "ruff failed".red().bold()).ok();
-                // Currently we generally only see one error, but e.g. with io errors when resolving
-                // the configuration it is help to chain errors ("resolving configuration failed" ->
-                // "failed to read file: subdir/pyproject.toml")
-                for cause in err.chain() {
-                    writeln!(stderr, "  {} {cause}", "Cause:".bold()).ok();
-                }
-            }
-            ExitStatus::Error.into()
-        }
-    }
-}
--- a/crates/ruff/src/printer.rs
+++ b/crates/ruff/src/printer.rs
@@ -1,551 +0,0 @@
-use std::cmp::Reverse;
-use std::hash::Hash;
-use std::io::Write;
-
-use anyhow::Result;
-use bitflags::bitflags;
-use colored::Colorize;
-use itertools::{Itertools, iterate};
-use ruff_linter::codes::NoqaCode;
-use serde::Serialize;
-
-use ruff_linter::fs::relativize_path;
-use ruff_linter::logging::LogLevel;
-use ruff_linter::message::{
-    AzureEmitter, Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter,
-    JsonEmitter, JsonLinesEmitter, JunitEmitter, Message, PylintEmitter, RdjsonEmitter,
-    SarifEmitter, TextEmitter,
-};
-use ruff_linter::notify_user;
-use ruff_linter::settings::flags::{self};
-use ruff_linter::settings::types::{OutputFormat, UnsafeFixes};
-
-use crate::diagnostics::{Diagnostics, FixMap};
-
-bitflags! {
-    #[derive(Default, Debug, Copy, Clone)]
-    pub(crate) struct Flags: u8 {
-        /// Whether to show violations when emitting diagnostics.
-        const SHOW_VIOLATIONS = 1 << 0;
-        /// Whether to show a summary of the fixed violations when emitting diagnostics.
-        const SHOW_FIX_SUMMARY = 1 << 1;
-        /// Whether to show a diff of each fixed violation when emitting diagnostics.
-        const SHOW_FIX_DIFF = 1 << 2;
-    }
-}
-
-#[derive(Serialize)]
-struct ExpandedStatistics {
-    code: Option<NoqaCode>,
-    name: &'static str,
-    count: usize,
-    fixable: bool,
-}
-
-pub(crate) struct Printer {
-    format: OutputFormat,
-    log_level: LogLevel,
-    fix_mode: flags::FixMode,
-    unsafe_fixes: UnsafeFixes,
-    flags: Flags,
-}
-
-impl Printer {
-    pub(crate) const fn new(
-        format: OutputFormat,
-        log_level: LogLevel,
-        fix_mode: flags::FixMode,
-        unsafe_fixes: UnsafeFixes,
-        flags: Flags,
-    ) -> Self {
-        Self {
-            format,
-            log_level,
-            fix_mode,
-            unsafe_fixes,
-            flags,
-        }
-    }
-
-    pub(crate) fn write_to_user(&self, message: &str) {
-        if self.log_level >= LogLevel::Default {
-            notify_user!("{}", message);
-        }
-    }
-
-    fn write_summary_text(&self, writer: &mut dyn Write, diagnostics: &Diagnostics) -> Result<()> {
-        if self.log_level >= LogLevel::Default {
-            let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
-
-            let fixed = diagnostics
-                .fixed
-                .values()
-                .flat_map(std::collections::HashMap::values)
-                .sum::<usize>();
-
-            if self.flags.intersects(Flags::SHOW_VIOLATIONS) {
-                let remaining = diagnostics.messages.len();
-                let total = fixed + remaining;
-                if fixed > 0 {
-                    let s = if total == 1 { "" } else { "s" };
-                    writeln!(
-                        writer,
-                        "Found {total} error{s} ({fixed} fixed, {remaining} remaining)."
-                    )?;
-                } else if remaining > 0 {
-                    let s = if remaining == 1 { "" } else { "s" };
-                    writeln!(writer, "Found {remaining} error{s}.")?;
-                } else if remaining == 0 {
-                    writeln!(writer, "All checks passed!")?;
-                }
-
-                if let Some(fixables) = fixables {
-                    let fix_prefix = format!("[{}]", "*".cyan());
-
-                    if self.unsafe_fixes.is_hint() {
-                        if fixables.applicable > 0 && fixables.inapplicable_unsafe > 0 {
-                            let es = if fixables.inapplicable_unsafe == 1 {
-                                ""
-                            } else {
-                                "es"
-                            };
-                            writeln!(
-                                writer,
-                                "{fix_prefix} {} fixable with the `--fix` option ({} hidden fix{es} can be enabled with the `--unsafe-fixes` option).",
-                                fixables.applicable, fixables.inapplicable_unsafe
-                            )?;
-                        } else if fixables.applicable > 0 {
-                            // Only applicable fixes
-                            writeln!(
-                                writer,
-                                "{fix_prefix} {} fixable with the `--fix` option.",
-                                fixables.applicable,
-                            )?;
-                        } else {
-                            // Only inapplicable fixes
-                            let es = if fixables.inapplicable_unsafe == 1 {
-                                ""
-                            } else {
-                                "es"
-                            };
-                            writeln!(
-                                writer,
-                                "No fixes available ({} hidden fix{es} can be enabled with the `--unsafe-fixes` option).",
-                                fixables.inapplicable_unsafe
-                            )?;
-                        }
-                    } else {
-                        if fixables.applicable > 0 {
-                            writeln!(
-                                writer,
-                                "{fix_prefix} {} fixable with the --fix option.",
-                                fixables.applicable
-                            )?;
-                        }
-                    }
-                }
-            } else {
-                // Check if there are unapplied fixes
-                let unapplied = {
-                    if let Some(fixables) = fixables {
-                        fixables.inapplicable_unsafe
-                    } else {
-                        0
-                    }
-                };
-
-                if unapplied > 0 {
-                    let es = if unapplied == 1 { "" } else { "es" };
-                    if fixed > 0 {
-                        let s = if fixed == 1 { "" } else { "s" };
-                        if self.fix_mode.is_apply() {
-                            writeln!(
-                                writer,
-                                "Fixed {fixed} error{s} ({unapplied} additional fix{es} available with `--unsafe-fixes`)."
-                            )?;
-                        } else {
-                            writeln!(
-                                writer,
-                                "Would fix {fixed} error{s} ({unapplied} additional fix{es} available with `--unsafe-fixes`)."
-                            )?;
-                        }
-                    } else {
-                        if self.fix_mode.is_apply() {
-                            writeln!(
-                                writer,
-                                "No errors fixed ({unapplied} fix{es} available with `--unsafe-fixes`)."
-                            )?;
-                        } else {
-                            writeln!(
-                                writer,
-                                "No errors would be fixed ({unapplied} fix{es} available with `--unsafe-fixes`)."
-                            )?;
-                        }
-                    }
-                } else {
-                    if fixed > 0 {
-                        let s = if fixed == 1 { "" } else { "s" };
-                        if self.fix_mode.is_apply() {
-                            writeln!(writer, "Fixed {fixed} error{s}.")?;
-                        } else {
-                            writeln!(writer, "Would fix {fixed} error{s}.")?;
-                        }
-                    }
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub(crate) fn write_once(
-        &self,
-        diagnostics: &Diagnostics,
-        writer: &mut dyn Write,
-    ) -> Result<()> {
-        if matches!(self.log_level, LogLevel::Silent) {
-            return Ok(());
-        }
-
-        if !self.flags.intersects(Flags::SHOW_VIOLATIONS) {
-            if matches!(
-                self.format,
-                OutputFormat::Full | OutputFormat::Concise | OutputFormat::Grouped
-            ) {
-                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
-                    if !diagnostics.fixed.is_empty() {
-                        writeln!(writer)?;
-                        print_fix_summary(writer, &diagnostics.fixed)?;
-                        writeln!(writer)?;
-                    }
-                }
-                self.write_summary_text(writer, diagnostics)?;
-            }
-            return Ok(());
-        }
-
-        let context = EmitterContext::new(&diagnostics.notebook_indexes);
-        let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
-
-        match self.format {
-            OutputFormat::Json => {
-                JsonEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Rdjson => {
-                RdjsonEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::JsonLines => {
-                JsonLinesEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Junit => {
-                JunitEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Concise | OutputFormat::Full => {
-                TextEmitter::default()
-                    .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
-                    .with_show_fix_diff(self.flags.intersects(Flags::SHOW_FIX_DIFF))
-                    .with_show_source(self.format == OutputFormat::Full)
-                    .with_unsafe_fixes(self.unsafe_fixes)
-                    .emit(writer, &diagnostics.messages, &context)?;
-
-                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
-                    if !diagnostics.fixed.is_empty() {
-                        writeln!(writer)?;
-                        print_fix_summary(writer, &diagnostics.fixed)?;
-                        writeln!(writer)?;
-                    }
-                }
-
-                self.write_summary_text(writer, diagnostics)?;
-            }
-            OutputFormat::Grouped => {
-                GroupedEmitter::default()
-                    .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
-                    .with_unsafe_fixes(self.unsafe_fixes)
-                    .emit(writer, &diagnostics.messages, &context)?;
-
-                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
-                    if !diagnostics.fixed.is_empty() {
-                        writeln!(writer)?;
-                        print_fix_summary(writer, &diagnostics.fixed)?;
-                        writeln!(writer)?;
-                    }
-                }
-                self.write_summary_text(writer, diagnostics)?;
-            }
-            OutputFormat::Github => {
-                GithubEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Gitlab => {
-                GitlabEmitter::default().emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Pylint => {
-                PylintEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Azure => {
-                AzureEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-            OutputFormat::Sarif => {
-                SarifEmitter.emit(writer, &diagnostics.messages, &context)?;
-            }
-        }
-
-        writer.flush()?;
-
-        Ok(())
-    }
-
-    pub(crate) fn write_statistics(
-        &self,
-        diagnostics: &Diagnostics,
-        writer: &mut dyn Write,
-    ) -> Result<()> {
-        let statistics: Vec<ExpandedStatistics> = diagnostics
-            .messages
-            .iter()
-            .map(|message| (message.to_noqa_code(), message))
-            .sorted_by_key(|(code, message)| (*code, message.fixable()))
-            .fold(
-                vec![],
-                |mut acc: Vec<((Option<NoqaCode>, &Message), usize)>, (code, message)| {
-                    if let Some(((prev_code, _prev_message), count)) = acc.last_mut() {
-                        if *prev_code == code {
-                            *count += 1;
-                            return acc;
-                        }
-                    }
-                    acc.push(((code, message), 1));
-                    acc
-                },
-            )
-            .iter()
-            .map(|&((code, message), count)| ExpandedStatistics {
-                code,
-                name: message.name(),
-                count,
-                fixable: if let Some(fix) = message.fix() {
-                    fix.applies(self.unsafe_fixes.required_applicability())
-                } else {
-                    false
-                },
-            })
-            .sorted_by_key(|statistic| Reverse(statistic.count))
-            .collect();
-
-        if statistics.is_empty() {
-            return Ok(());
-        }
-
-        match self.format {
-            OutputFormat::Full | OutputFormat::Concise => {
-                // Compute the maximum number of digits in the count and code, for all messages,
-                // to enable pretty-printing.
-                let count_width = num_digits(
-                    statistics
-                        .iter()
-                        .map(|statistic| statistic.count)
-                        .max()
-                        .unwrap(),
-                );
-                let code_width = statistics
-                    .iter()
-                    .map(|statistic| {
-                        statistic
-                            .code
-                            .map_or_else(String::new, |rule| rule.to_string())
-                            .len()
-                    })
-                    .max()
-                    .unwrap();
-                let any_fixable = statistics.iter().any(|statistic| statistic.fixable);
-
-                let fixable = format!("[{}] ", "*".cyan());
-                let unfixable = "[ ] ";
-
-                // By default, we mimic Flake8's `--statistics` format.
-                for statistic in statistics {
-                    writeln!(
-                        writer,
-                        "{:>count_width$}\t{:<code_width$}\t{}{}",
-                        statistic.count.to_string().bold(),
-                        statistic
-                            .code
-                            .map_or_else(String::new, |rule| rule.to_string())
-                            .red()
-                            .bold(),
-                        if any_fixable {
-                            if statistic.fixable {
-                                &fixable
-                            } else {
-                                unfixable
-                            }
-                        } else {
-                            ""
-                        },
-                        statistic.name,
-                    )?;
-                }
-
-                self.write_summary_text(writer, diagnostics)?;
-                return Ok(());
-            }
-            OutputFormat::Json => {
-                writeln!(writer, "{}", serde_json::to_string_pretty(&statistics)?)?;
-            }
-            _ => {
-                anyhow::bail!(
-                    "Unsupported serialization format for statistics: {:?}",
-                    self.format
-                )
-            }
-        }
-
-        writer.flush()?;
-
-        Ok(())
-    }
-
-    pub(crate) fn write_continuously(
-        &self,
-        writer: &mut dyn Write,
-        diagnostics: &Diagnostics,
-        preview: bool,
-    ) -> Result<()> {
-        if matches!(self.log_level, LogLevel::Silent) {
-            return Ok(());
-        }
-
-        if self.log_level >= LogLevel::Default {
-            let s = if diagnostics.messages.len() == 1 {
-                ""
-            } else {
-                "s"
-            };
-            notify_user!(
-                "Found {} error{s}. Watching for file changes.",
-                diagnostics.messages.len()
-            );
-        }
-
-        let fixables = FixableStatistics::try_from(diagnostics, self.unsafe_fixes);
-
-        if !diagnostics.messages.is_empty() {
-            if self.log_level >= LogLevel::Default {
-                writeln!(writer)?;
-            }
-
-            let context = EmitterContext::new(&diagnostics.notebook_indexes);
-            TextEmitter::default()
-                .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
-                .with_show_source(preview)
-                .with_unsafe_fixes(self.unsafe_fixes)
-                .emit(writer, &diagnostics.messages, &context)?;
-        }
-        writer.flush()?;
-
-        Ok(())
-    }
-
-    pub(crate) fn clear_screen() -> Result<()> {
-        #[cfg(not(target_family = "wasm"))]
-        clearscreen::clear()?;
-        Ok(())
-    }
-}
-
-fn num_digits(n: usize) -> usize {
-    iterate(n, |&n| n / 10)
-        .take_while(|&n| n > 0)
-        .count()
-        .max(1)
-}
-
-/// Return `true` if the [`Printer`] should indicate that a rule is fixable.
-fn show_fix_status(fix_mode: flags::FixMode, fixables: Option<&FixableStatistics>) -> bool {
-    // If we're in application mode, avoid indicating that a rule is fixable.
-    // If the specific violation were truly fixable, it would've been fixed in
-    // this pass! (We're occasionally unable to determine whether a specific
-    // violation is fixable without trying to fix it, so if fix is not
-    // enabled, we may inadvertently indicate that a rule is fixable.)
-    (!fix_mode.is_apply()) && fixables.is_some_and(FixableStatistics::any_applicable_fixes)
-}
-
-fn print_fix_summary(writer: &mut dyn Write, fixed: &FixMap) -> Result<()> {
-    let total = fixed
-        .values()
-        .map(|table| table.values().sum::<usize>())
-        .sum::<usize>();
-    assert!(total > 0);
-    let num_digits = num_digits(
-        *fixed
-            .values()
-            .filter_map(|table| table.values().max())
-            .max()
-            .unwrap(),
-    );
-
-    let s = if total == 1 { "" } else { "s" };
-    let label = format!("Fixed {total} error{s}:");
-    writeln!(writer, "{}", label.bold().green())?;
-
-    for (filename, table) in fixed
-        .iter()
-        .sorted_by_key(|(filename, ..)| filename.as_str())
-    {
-        writeln!(
-            writer,
-            "{} {}{}",
-            "-".cyan(),
-            relativize_path(filename).bold(),
-            ":".cyan()
-        )?;
-        for (rule, count) in table.iter().sorted_by_key(|(.., count)| Reverse(*count)) {
-            writeln!(
-                writer,
-                "    {count:>num_digits$} × {} ({})",
-                rule.noqa_code().to_string().red().bold(),
-                rule.as_ref(),
-            )?;
-        }
-    }
-    Ok(())
-}
-
-/// Statistics for [applicable][ruff_diagnostics::Applicability] fixes.
-#[derive(Debug)]
-struct FixableStatistics {
-    applicable: u32,
-    inapplicable_unsafe: u32,
-}
-
-impl FixableStatistics {
-    fn try_from(diagnostics: &Diagnostics, unsafe_fixes: UnsafeFixes) -> Option<Self> {
-        let mut applicable = 0;
-        let mut inapplicable_unsafe = 0;
-
-        for message in &diagnostics.messages {
-            if let Some(fix) = message.fix() {
-                if fix.applies(unsafe_fixes.required_applicability()) {
-                    applicable += 1;
-                } else {
-                    // Do not include inapplicable fixes at other levels that do not provide an opt-in
-                    if fix.applicability().is_unsafe() {
-                        inapplicable_unsafe += 1;
-                    }
-                }
-            }
-        }
-
-        if applicable == 0 && inapplicable_unsafe == 0 {
-            None
-        } else {
-            Some(Self {
-                applicable,
-                inapplicable_unsafe,
-            })
-        }
-    }
-
-    fn any_applicable_fixes(&self) -> bool {
-        self.applicable > 0
-    }
-}
--- a/crates/ruff/src/resolve.rs
+++ b/crates/ruff/src/resolve.rs
@@ -1,145 +0,0 @@
-use std::path::Path;
-
-use anyhow::{Result, bail};
-use log::debug;
-use path_absolutize::path_dedot;
-
-use ruff_workspace::configuration::Configuration;
-use ruff_workspace::pyproject::{self, find_fallback_target_version};
-use ruff_workspace::resolver::{
-    ConfigurationOrigin, ConfigurationTransformer, PyprojectConfig, PyprojectDiscoveryStrategy,
-    resolve_root_settings,
-};
-
-use ruff_python_ast as ast;
-
-use crate::args::ConfigArguments;
-
-/// Resolve the relevant settings strategy and defaults for the current
-/// invocation.
-pub fn resolve(
-    config_arguments: &ConfigArguments,
-    stdin_filename: Option<&Path>,
-) -> Result<PyprojectConfig> {
-    let Ok(cwd) = std::env::current_dir() else {
-        bail!("Working directory does not exist")
-    };
-
-    // First priority: if we're running in isolated mode, use the default settings.
-    if config_arguments.isolated {
-        let config = config_arguments.transform(Configuration::default());
-        let settings = config.into_settings(&cwd)?;
-        debug!("Isolated mode, not reading any pyproject.toml");
-        return Ok(PyprojectConfig::new(
-            PyprojectDiscoveryStrategy::Fixed,
-            settings,
-            None,
-        ));
-    }
-
-    // Second priority: the user specified a `pyproject.toml` file. Use that
-    // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
-    // current working directory. (This matches ESLint's behavior.)
-    if let Some(pyproject) = config_arguments.config_file() {
-        let settings = resolve_root_settings(
-            pyproject,
-            config_arguments,
-            ConfigurationOrigin::UserSpecified,
-        )?;
-        debug!(
-            "Using user-specified configuration file at: {}",
-            pyproject.display()
-        );
-        return Ok(PyprojectConfig::new(
-            PyprojectDiscoveryStrategy::Fixed,
-            settings,
-            Some(pyproject.to_path_buf()),
-        ));
-    }
-
-    // Third priority: find a `pyproject.toml` file in either an ancestor of
-    // `stdin_filename` (if set) or the current working path all paths relative to
-    // that directory. (With `Strategy::Hierarchical`, we'll end up finding
-    // the "closest" `pyproject.toml` file for every Python file later on,
-    // so these act as the "default" settings.)
-    if let Some(pyproject) = pyproject::find_settings_toml(stdin_filename.unwrap_or(&cwd))? {
-        debug!(
-            "Using configuration file (via parent) at: {}",
-            pyproject.display()
-        );
-        let settings =
-            resolve_root_settings(&pyproject, config_arguments, ConfigurationOrigin::Ancestor)?;
-        return Ok(PyprojectConfig::new(
-            PyprojectDiscoveryStrategy::Hierarchical,
-            settings,
-            Some(pyproject),
-        ));
-    }
-
-    // Fourth priority: find a user-specific `pyproject.toml`, but resolve all paths
-    // relative the current working directory. (With `Strategy::Hierarchical`, we'll
-    // end up the "closest" `pyproject.toml` file for every Python file later on, so
-    // these act as the "default" settings.)
-    if let Some(pyproject) = pyproject::find_user_settings_toml() {
-        struct FallbackTransformer<'a> {
-            arguments: &'a ConfigArguments,
-        }
-
-        impl ConfigurationTransformer for FallbackTransformer<'_> {
-            fn transform(&self, mut configuration: Configuration) -> Configuration {
-                // The `requires-python` constraint from the `pyproject.toml` takes precedence
-                // over the `target-version` from the user configuration.
-                let fallback = find_fallback_target_version(&*path_dedot::CWD);
-                if let Some(fallback) = fallback {
-                    debug!("Derived `target-version` from found `requires-python`: {fallback:?}");
-                    configuration.target_version = Some(fallback.into());
-                }
-
-                self.arguments.transform(configuration)
-            }
-        }
-
-        debug!(
-            "Using configuration file (via cwd) at: {}",
-            pyproject.display()
-        );
-        let settings = resolve_root_settings(
-            &pyproject,
-            &FallbackTransformer {
-                arguments: config_arguments,
-            },
-            ConfigurationOrigin::UserSettings,
-        )?;
-        return Ok(PyprojectConfig::new(
-            PyprojectDiscoveryStrategy::Hierarchical,
-            settings,
-            Some(pyproject),
-        ));
-    }
-
-    // Fallback: load Ruff's default settings, and resolve all paths relative to the
-    // current working directory. (With `Strategy::Hierarchical`, we'll end up the
-    // "closest" `pyproject.toml` file for every Python file later on, so these act
-    // as the "default" settings.)
-    debug!("Using Ruff default settings");
-    let mut config = config_arguments.transform(Configuration::default());
-    if config.target_version.is_none() {
-        // If we have arrived here we know that there was no `pyproject.toml`
-        // containing a `[tool.ruff]` section found in an ancestral directory.
-        // (This is an implicit requirement in the function
-        // `pyproject::find_settings_toml`.)
-        // However, there may be a `pyproject.toml` with a `requires-python`
-        // specified, and that is what we look for in this step.
-        let fallback = find_fallback_target_version(stdin_filename.unwrap_or(&cwd));
-        if let Some(version) = fallback {
-            debug!("Derived `target-version` from found `requires-python`: {version:?}");
-        }
-        config.target_version = fallback.map(ast::PythonVersion::from);
-    }
-    let settings = config.into_settings(&cwd)?;
-    Ok(PyprojectConfig::new(
-        PyprojectDiscoveryStrategy::Hierarchical,
-        settings,
-        None,
-    ))
-}
--- a/crates/ruff/src/snapshots/ruffversiontests__version_formatting.snap
+++ b/crates/ruff/src/snapshots/ruffversiontests__version_formatting.snap
@@ -1,6 +0,0 @@
---
-source: crates/ruff/src/version.rs
-expression: version
-snapshot_kind: text
---
-0.0.0
--- a/Show More
+++ b/Show More