tempest-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to **tempest-cli** are listed below.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] — 2026-08-15
+
+### Changed
+
+- **`ruff` now ships with the package.** It moved from the `[tools]`
+  extra into the runtime dependencies, so `uv add --dev tempest-cli` is
+  enough for `lint`, `fix`, `format` and `fmt-check` to run — no second
+  install, and no dependency on `uv` being around to fetch one. The cost
+  is nil: ruff is a static binary wheel with no Python dependencies of
+  its own, so no bound of its reaches a consumer's resolution.
+
+  `mypy` and `pytest` stay out on purpose. A mypy bump changes which
+  errors a codebase reports and pytest has to match the suite and its
+  plugins — those are the project's call. `[tools]` now installs exactly
+  those two.
+
+- **The project's environment is searched before the CLI's own.** With
+  ruff bundled, the CLI's environment always has one; looking there
+  first would silently override a version the project pinned whenever
+  `tempest-cli` is installed apart from it (`uv tool install`, pipx).
+  The order is now `$VIRTUAL_ENV` → nearest `.venv` → the CLI's own
+  environment → `PATH` → `uv run --with`.
+
 ## [0.2.0] — 2026-08-15
 
 ### Added

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tempest-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Framework-agnostic quality gate for Python projects: ruff + mypy + pytest behind one command, with a typing-strictness dial and a PR-description prompt generator.
 Project-URL: Homepage, https://github.com/mauriciobenjamin700/tempest-cli
 Project-URL: Repository, https://github.com/mauriciobenjamin700/tempest-cli
@@ -22,11 +22,11 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
+Requires-Dist: ruff>=0.8.0
 Requires-Dist: typer>=0.12.0
 Provides-Extra: tools
 Requires-Dist: mypy>=1.13.0; extra == 'tools'
 Requires-Dist: pytest>=8.3.3; extra == 'tools'
-Requires-Dist: ruff>=0.8.0; extra == 'tools'
 Description-Content-Type: text/markdown
 
 # tempest-cli
@@ -42,7 +42,8 @@ One command for the quality gate of any Python project — `ruff` +
 `pyproject.toml` instead of in four different Makefile targets.
 
 Framework-agnostic on purpose: Django, Flask, Litestar, FastAPI, a
-library, a script. The only runtime dependency is `typer`.
+library, a script. It brings `ruff` along, so the gate runs the moment
+you install it; `typer` is the only other runtime dependency.
 
 ```bash
 uv add --dev tempest-cli
@@ -141,24 +142,33 @@ cli: typer.Typer = typer.Typer(name="mytool")
 register_commands(cli)
 ```
 
-## Installing the tools
+## Where the tools come from
 
-`tempest-cli` shells out to whatever `ruff`, `mypy` and `pytest` it
-finds — it does not pin them, so your project chooses the versions. The
-lookup runs in this order:
+**`ruff` comes with the package** — six of the eight commands are ruff,
+so `lint`, `fix`, `format` and `fmt-check` work straight after
+`uv add --dev tempest-cli`, with nothing else to install. It is a static
+binary wheel with no Python dependencies of its own, so nothing of its
+propagates into your resolution.
 
-1. the environments of the run — the interpreter's own directory, then
-   `$VIRTUAL_ENV`, then the nearest `.venv` up the tree;
-2. `PATH`, skipping a pyenv/asdf shim that dispatches nowhere (the one
-   that answers `pyenv: ruff: command not found`);
-3. `uv run --with <tool> <tool>`, when `uv` is available.
-
-To install the three alongside it:
+`mypy` and `pytest` are deliberately left to you — a mypy bump changes
+which errors your code reports, and pytest has to match your plugins and
+your suite. Add them yourself, or take the bundle:
 
 ```bash
 uv add --dev "tempest-cli[tools]"
 ```
 
+Whatever you pin wins over the bundled ruff. The lookup runs in this
+order:
+
+1. the project's environment — `$VIRTUAL_ENV`, then the nearest `.venv`
+   up the tree;
+2. the environment `tempest-cli` itself runs from (where the bundled
+   ruff lives);
+3. `PATH`, skipping a pyenv/asdf shim that dispatches nowhere (the one
+   that answers `pyenv: ruff: command not found`);
+4. `uv run --with <tool> <tool>`, when `uv` is available.
+
 ## Relationship with tempest-fastapi-sdk
 
 This package was extracted from

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/README.md

@@ -11,7 +11,8 @@ One command for the quality gate of any Python project — `ruff` +
 `pyproject.toml` instead of in four different Makefile targets.
 
 Framework-agnostic on purpose: Django, Flask, Litestar, FastAPI, a
-library, a script. The only runtime dependency is `typer`.
+library, a script. It brings `ruff` along, so the gate runs the moment
+you install it; `typer` is the only other runtime dependency.
 
 ```bash
 uv add --dev tempest-cli
@@ -110,24 +111,33 @@ cli: typer.Typer = typer.Typer(name="mytool")
 register_commands(cli)
 ```
 
-## Installing the tools
+## Where the tools come from
 
-`tempest-cli` shells out to whatever `ruff`, `mypy` and `pytest` it
-finds — it does not pin them, so your project chooses the versions. The
-lookup runs in this order:
+**`ruff` comes with the package** — six of the eight commands are ruff,
+so `lint`, `fix`, `format` and `fmt-check` work straight after
+`uv add --dev tempest-cli`, with nothing else to install. It is a static
+binary wheel with no Python dependencies of its own, so nothing of its
+propagates into your resolution.
 
-1. the environments of the run — the interpreter's own directory, then
-   `$VIRTUAL_ENV`, then the nearest `.venv` up the tree;
-2. `PATH`, skipping a pyenv/asdf shim that dispatches nowhere (the one
-   that answers `pyenv: ruff: command not found`);
-3. `uv run --with <tool> <tool>`, when `uv` is available.
-
-To install the three alongside it:
+`mypy` and `pytest` are deliberately left to you — a mypy bump changes
+which errors your code reports, and pytest has to match your plugins and
+your suite. Add them yourself, or take the bundle:
 
 ```bash
 uv add --dev "tempest-cli[tools]"
 ```
 
+Whatever you pin wins over the bundled ruff. The lookup runs in this
+order:
+
+1. the project's environment — `$VIRTUAL_ENV`, then the nearest `.venv`
+   up the tree;
+2. the environment `tempest-cli` itself runs from (where the bundled
+   ruff lives);
+3. `PATH`, skipping a pyenv/asdf shim that dispatches nowhere (the one
+   that answers `pyenv: ruff: command not found`);
+4. `uv run --with <tool> <tool>`, when `uv` is available.
+
 ## Relationship with tempest-fastapi-sdk
 
 This package was extracted from

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/docs/changelog.en.md

@@ -3,6 +3,23 @@
 The full history lives in the repository's
 [`CHANGELOG.md`](https://github.com/mauriciobenjamin700/tempest-cli/blob/main/CHANGELOG.md).
 
+## [0.3.0] — 2026-08-15
+
+### Changed
+
+- **`ruff` now ships with the package.** It left the `[tools]` extra for
+  the runtime dependencies, so `uv add --dev tempest-cli` is enough for
+  `lint`, `fix`, `format` and `fmt-check` to run. The cost is nil: ruff
+  is a static binary wheel with no Python dependencies of its own, so no
+  bound of its reaches a consumer's resolution. `mypy` and `pytest` stay
+  out on purpose; `[tools]` now installs exactly those two.
+- **The project's environment is searched before the CLI's own.** With
+  ruff bundled, the CLI's environment always has one — looking there
+  first would silently override a version the project pinned whenever
+  `tempest-cli` lives apart from it (`uv tool install`, pipx). The order
+  is now `$VIRTUAL_ENV` → nearest `.venv` → the CLI's environment →
+  `PATH` → `uv run --with`.
+
 ## [0.2.0] — 2026-08-15
 
 ### Added

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/docs/changelog.md

@@ -4,6 +4,23 @@ O histórico completo vive no
 [`CHANGELOG.md`](https://github.com/mauriciobenjamin700/tempest-cli/blob/main/CHANGELOG.md)
 do repositório.
 
+## [0.3.0] — 2026-08-15
+
+### Mudado
+
+- **O `ruff` agora vem junto com o pacote.** Saiu do extra `[tools]` e
+  virou dependência: `uv add --dev tempest-cli` já basta para `lint`,
+  `fix`, `format` e `fmt-check` rodarem. Custo zero — o ruff é binário
+  estático, sem dependência Python, então nenhum limite dele entra na
+  resolução de quem instala. `mypy` e `pytest` continuam de fora de
+  propósito; `[tools]` agora instala exatamente esses dois.
+- **O ambiente do projeto passa a ser procurado antes do da CLI.** Com o
+  ruff embutido, o ambiente da CLI sempre tem um — procurar ali primeiro
+  sobrescreveria em silêncio a versão que o projeto fixou quando o
+  `tempest-cli` mora fora dele (`uv tool install`, pipx). A ordem agora é
+  `$VIRTUAL_ENV` → `.venv` mais próximo → ambiente da CLI → `PATH` →
+  `uv run --with`.
+
 ## [0.2.0] — 2026-08-15
 
 ### Adicionado

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/docs/index.en.md

@@ -5,7 +5,9 @@ and `pytest` — with the typing strictness living in `pyproject.toml`
 instead of spread across four Makefile targets.
 
 Framework-agnostic on purpose: Django, Flask, Litestar, FastAPI, a
-library, a script. The only runtime dependency is `typer`.
+library, a script. There are two runtime dependencies: `typer` and
+`ruff` — the latter ships along, so the gate runs the moment you install
+it.
 
 ```bash
 uv add --dev tempest-cli

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/docs/index.md

@@ -5,7 +5,9 @@ Um comando para o gate de qualidade de qualquer projeto Python — `ruff`,
 em vez de espalhado por quatro alvos de Makefile.
 
 Agnóstico de framework de propósito: Django, Flask, Litestar, FastAPI,
-uma biblioteca, um script. A única dependência de runtime é o `typer`.
+uma biblioteca, um script. As dependências de runtime são duas: o
+`typer` e o `ruff` — que já vem junto, para o gate rodar assim que
+instala.
 
 ```bash
 uv add --dev tempest-cli

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/docs/installation.en.md

@@ -10,7 +10,9 @@ Or with pip:
 pip install tempest-cli
 ```
 
-Requires **Python 3.11+**. The only runtime dependency is `typer`.
+Requires **Python 3.11+**. It brings `ruff` along — six of the eight
+commands are ruff, so the gate runs the moment the package installs. The
+other runtime dependency is `typer`.
 
 It installs **two executables**: `tempest-cli` and the short alias `tc`.
 They are the same program — everything in these docs applies to both.
@@ -26,15 +28,42 @@ tc check        # identical to tempest-cli check
 
 ## Where ruff, mypy and pytest come from
 
-`tempest-cli` does **not** pin any of the three: it runs whatever it
-finds, in this order:
+**`ruff` comes with the package**: install it and `lint`, `fix`,
+`format` and `fmt-check` already work — nothing else to install.
 
-1. **the environments of the run** — the directory of the interpreter
-   running the CLI (where the `[tools]` extra installs all three), then
-   `$VIRTUAL_ENV`, then the nearest `.venv` up the tree;
-2. **`PATH`** — skipping a version-manager shim that dispatches nowhere
+```bash
+uv add --dev tempest-cli
+tempest-cli fix            # runs right away
+```
+
+`mypy` and `pytest` stay with you. A mypy bump changes which errors your
+code starts reporting, and pytest has to match your plugins and your
+suite — those versions are the project's call. Add them yourself, or
+take the bundle:
+
+```bash
+uv add --dev "tempest-cli[tools]"   # mypy + pytest
+```
+
+!!! question "Why ruff is a dependency and the other two are not"
+    Six of the eight commands are ruff — a `tempest-cli` without ruff is
+    a gate that cannot run. And it costs nothing: ruff is a static
+    binary with no Python dependencies at all, so no bound of its enters
+    your project's resolution. mypy and pytest, in contrast, run through
+    your code and your suite; pinning them here would be deciding for
+    you.
+
+### The lookup order
+
+What your project pins **wins** over the bundled ruff. The CLI runs the
+first thing it finds, in this order:
+
+1. **the project's environment** — `$VIRTUAL_ENV`, then the nearest
+   `.venv` up the tree;
+2. **the CLI's own environment** — where the bundled ruff lives;
+3. **`PATH`** — skipping a version-manager shim that dispatches nowhere
    (see below);
-3. **`uv run --with <tool> <tool>`** when `uv` is available — the
+4. **`uv run --with <tool> <tool>`** when `uv` is available — the
    project's environment plus the tool, with no activation and no prior
    `uv sync` required.
 
@@ -46,22 +75,10 @@ tool and how to install it, instead of raising a traceback.
     globally and holds a stub for every tool any installed version ever
     provided. Looking up `ruff` there finds `~/.pyenv/shims/ruff` even
     when the project has no ruff at all — and running it prints
-    `pyenv: ruff: command not found`. So the run's own environment wins
+    `pyenv: ruff: command not found`. So the run's own environments win
     over `PATH`, and a shim is only accepted after proving it dispatches
     (`<tool> --version` exiting `0`).
 
-!!! tip "Why the versions are not pinned"
-    A ruff version pinned here would become the ceiling for every
-    project installing this package — and upgrading the linter is a
-    decision for whoever writes the code, not for whoever packages the
-    gate.
-
-If you would rather install all three alongside:
-
-```bash
-uv add --dev "tempest-cli[tools]"
-```
-
 ## Verifying
 
 ```bash
@@ -82,9 +99,9 @@ it exactly as it would read `ruff` directly:
 
 ## Recap
 
-- `uv add --dev tempest-cli`, Python 3.11+, `typer` as the only
-  dependency.
+- `uv add --dev tempest-cli`, Python 3.11+, `ruff` already included.
+- `mypy` and `pytest` are yours — or take `"tempest-cli[tools]"`.
 - Two executables: `tempest-cli` and the `tc` alias.
-- Tools come from the run's environment, from `PATH` (never a dead
-  shim), or through `uv run --with`.
+- What the project pins beats the bundled ruff; then come `PATH` (never
+  a dead shim) and `uv run --with`.
 - A missing tool means exit 127 with a message, not a traceback.

tempest_cli-0.3.0/docs/installation.md

@@ -0,0 +1,107 @@
+# Instalação
+
+```bash
+uv add --dev tempest-cli
+```
+
+Ou com pip:
+
+```bash
+pip install tempest-cli
+```
+
+Requer **Python 3.11+**. Vem com o `ruff` junto — seis dos oito
+comandos são ruff, então o gate roda assim que o pacote instala. A outra
+dependência de runtime é o `typer`.
+
+Ficam instalados **dois executáveis**: `tempest-cli` e o apelido curto
+`tc`. São o mesmo programa — tudo nesta documentação vale para os dois.
+
+```bash
+tc check        # idêntico a tempest-cli check
+```
+
+!!! warning "`tc` também é o `tc(8)` do iproute2"
+    Enquanto o ambiente que instalou o pacote estiver no `PATH`, `tc`
+    resolve para esta CLI. Para o controlador de tráfego do Linux, chame
+    pelo caminho absoluto (`/usr/sbin/tc`) ou use `tempest-cli` e deixe
+    o `tc` livre.
+
+## De onde vêm o ruff, o mypy e o pytest
+
+O **`ruff` já vem junto**: instalou o pacote, `lint`, `fix`, `format` e
+`fmt-check` funcionam — nada mais a instalar.
+
+```bash
+uv add --dev tempest-cli
+tempest-cli fix            # roda agora mesmo
+```
+
+O `mypy` e o `pytest` ficam com você. Um bump de mypy muda quais erros o
+seu código passa a reportar, e o pytest precisa casar com os seus plugins
+e a sua suíte — versão dessas duas é decisão do projeto. Adicione você
+mesmo, ou pegue o pacote pronto:
+
+```bash
+uv add --dev "tempest-cli[tools]"   # mypy + pytest
+```
+
+!!! question "Por que o ruff é dependência e as outras duas não"
+    Seis dos oito comandos são ruff — um `tempest-cli` sem ruff é um
+    gate que não roda. E o custo é zero: o ruff é um binário estático,
+    sem dependência Python nenhuma, então nenhum limite dele entra na
+    resolução do seu projeto. Já mypy e pytest atravessam o seu código e
+    a sua suíte; fixá-los aqui seria decidir por você.
+
+### A ordem de busca
+
+O que o seu projeto fixa **ganha** do ruff que veio junto. A CLI executa
+o que encontrar primeiro, nesta ordem:
+
+1. **o ambiente do projeto** — `$VIRTUAL_ENV`, depois o `.venv` mais
+   próximo subindo a árvore;
+2. **o ambiente da própria CLI** — onde mora o ruff que veio junto;
+3. **o `PATH`** — pulando um *shim* de gerenciador de versão que não
+   despacha para lugar nenhum (veja abaixo);
+4. **`uv run --with <ferramenta> <ferramenta>`**, quando o `uv` está
+   disponível — o ambiente do projeto mais a ferramenta, sem exigir
+   ativação nem `uv sync` prévio.
+
+Se nada resolver, o comando sai com **127** e diz qual ferramenta faltou
+e como instalá-la, em vez de estourar um traceback.
+
+!!! info "Por que o `PATH` não vem primeiro"
+    Em máquina com pyenv/asdf, o diretório `shims` está no `PATH`
+    globalmente e tem um stub para toda ferramenta que qualquer versão
+    instalada já forneceu. Procurar `ruff` ali acha
+    `~/.pyenv/shims/ruff` mesmo quando o projeto não tem ruff nenhum — e
+    rodá-lo dá `pyenv: ruff: command not found`. Por isso os ambientes da
+    execução ganham do `PATH`, e um shim só é aceito depois de provar que
+    despacha (`<ferramenta> --version` saindo `0`).
+
+## Verificando
+
+```bash
+tempest-cli --version
+tc --version          # o mesmo programa
+tempest-cli check --help
+```
+
+## Em CI
+
+Cada comando devolve o código de saída da ferramenta por baixo, então o
+job lê exatamente como leria o `ruff` direto:
+
+```yaml
+- name: Quality gate
+  run: uv run tempest-cli check
+```
+
+## Recap
+
+- `uv add --dev tempest-cli`, Python 3.11+, com o `ruff` já junto.
+- `mypy` e `pytest` são seus — ou pegue `"tempest-cli[tools]"`.
+- Dois executáveis: `tempest-cli` e o apelido `tc`.
+- O que o projeto fixa ganha do ruff embutido; depois vêm o `PATH` (sem
+  shim morto) e o `uv run --with`.
+- Ferramenta ausente = saída 127 com mensagem, não traceback.

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tempest-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Framework-agnostic quality gate for Python projects: ruff + mypy + pytest behind one command, with a typing-strictness dial and a PR-description prompt generator."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -31,18 +31,25 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
+    # `ruff` ships with the package: six of the eight commands are ruff,
+    # so a tempest-cli without one is a gate that cannot run. It costs
+    # nothing to depend on — a static binary wheel with no Python
+    # dependencies of its own, so no bound of its propagates to anyone.
+    # The lookup still prefers a ruff the project pinned; this one is the
+    # fallback for a project that pinned none.
+    "ruff>=0.8.0",
     "typer>=0.12.0",
 ]
 
 [project.optional-dependencies]
-# The gate shells out to whatever `ruff` / `mypy` / `pytest` it finds on
-# PATH or in the active environment, so none of them is required to
-# install this package. `[tools]` is the convenience bundle for a project
-# that would rather pin them here than in its own dev group.
+# `mypy` and `pytest` are deliberately NOT dependencies. A mypy bump
+# changes which errors a codebase reports, and pytest has to match the
+# plugins and the test suite it runs — both are the project's call, not
+# this package's. `[tools]` is the convenience bundle for whoever would
+# rather pin them here than in their own dev group.
 tools = [
     "mypy>=1.13.0",
     "pytest>=8.3.3",
-    "ruff>=0.8.0",
 ]
 
 [project.urls]

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/tempest_cli/__init__.py

@@ -5,9 +5,11 @@ typing-strictness dial read from ``[tool.tempest]`` in the project's
 ``pyproject.toml`` — and a generator for the prompt that makes an AI fill
 a pull-request description from the branch's own diff.
 
-It knows nothing about any web framework. The only runtime dependency is
-``typer``; the tools themselves are invoked from the active environment,
-so a project pins the ruff and mypy versions it wants.
+It knows nothing about any web framework. ``ruff`` ships with it, so the
+lint/format commands work the moment it is installed; ``mypy`` and
+``pytest`` are left to the project, which pins the versions it wants.
+The tools are invoked from the project's environment first, so a pinned
+version always beats the bundled one.
 
 ```bash
 tempest-cli check                 # lint + fmt-check + type + test
@@ -49,7 +51,7 @@ from tempest_cli.pr_prompt import GitError as GitError
 from tempest_cli.pr_prompt import PromptLanguage as PromptLanguage
 from tempest_cli.pr_prompt import generate_pr_prompt as generate_pr_prompt
 
-__version__: str = "0.2.0"
+__version__: str = "0.3.0"
 """Installed package version."""
 
 __all__: list[str] = [

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/tempest_cli/lint.py

@@ -42,19 +42,25 @@ def _environment_dirs() -> list[Path]:
     environment has no ruff at all. The environments below are the ones
     that actually belong to the run, so they are consulted first:
 
-    1. the directory of the interpreter running this CLI — where the
-       ``[tools]`` extra installs ruff/mypy/pytest next to the
-       ``tempest-cli`` executable itself;
-    2. ``$VIRTUAL_ENV`` — the activated environment, which matters when
-       the CLI itself lives elsewhere (``uv tool install`` / pipx);
-    3. the nearest ``.venv`` walking up from the working directory — a
-       project environment that was never activated.
+    1. ``$VIRTUAL_ENV`` — the activated environment;
+    2. the nearest ``.venv`` walking up from the working directory — a
+       project environment that was never activated;
+    3. the directory of the interpreter running this CLI.
+
+    The project comes before the interpreter on purpose. ``ruff`` ships
+    as a dependency of this package, so the CLI's own environment always
+    has one; a project that pins its own must still get the version it
+    pinned, with the bundled one serving only as the fallback for a
+    project that pins nothing. When the CLI is installed *into* the
+    project (the common case) all three point at the same directory and
+    the order is moot — it only decides for ``uv tool install`` / pipx,
+    where the CLI lives in an environment of its own.
 
     Returns:
         list[Path]: Existing directories, in preference order, without
         duplicates.
     """
-    roots: list[Path] = [Path(sys.executable).parent]
+    roots: list[Path] = []
     virtual_env = os.environ.get("VIRTUAL_ENV")
     if virtual_env:
         roots.extend((Path(virtual_env) / "bin", Path(virtual_env) / "Scripts"))
@@ -68,6 +74,7 @@ def _environment_dirs() -> list[Path]:
             if candidate.is_dir():
                 roots.extend((candidate / "bin", candidate / "Scripts"))
                 break
+    roots.append(Path(sys.executable).parent)
     seen: set[Path] = set()
     ordered: list[Path] = []
     for root in roots:

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/tests/test_lint_runners.py

@@ -320,10 +320,16 @@ def test_a_shim_probe_that_cannot_spawn_is_not_runnable(
     assert lint._shim_runs(Path("/home/u/.pyenv/shims/ruff")) is False
 
 
-def test_environment_dirs_prefers_the_running_interpreter(
+def test_environment_dirs_prefers_the_project_over_the_cli_itself(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    """The CLI's own environment is searched before $VIRTUAL_ENV."""
+    """A pinned ruff must win over the one shipped with this package.
+
+    `ruff` is a dependency of tempest-cli, so the CLI's own environment
+    always has one. Searching it first would silently override the
+    version a project pinned whenever the CLI lives elsewhere
+    (`uv tool install` / pipx).
+    """
     interpreter_dir = tmp_path / "cli-env" / "bin"
     interpreter_dir.mkdir(parents=True)
     active = tmp_path / "active"
@@ -332,8 +338,8 @@ def test_environment_dirs_prefers_the_running_interpreter(
     monkeypatch.setenv("VIRTUAL_ENV", str(active))
     monkeypatch.chdir(tmp_path)
     dirs = lint._environment_dirs()
-    assert dirs[0] == interpreter_dir
-    assert active / "bin" in dirs
+    assert dirs[0] == active / "bin"
+    assert dirs.index(interpreter_dir) > dirs.index(active / "bin")
 
 
 def test_environment_dirs_finds_an_unactivated_venv(
@@ -346,3 +352,18 @@ def test_environment_dirs_finds_an_unactivated_venv(
     monkeypatch.delenv("VIRTUAL_ENV", raising=False)
     monkeypatch.chdir(project / "src")
     assert project / ".venv" / "bin" in lint._environment_dirs()
+
+
+def test_ruff_ships_with_the_package() -> None:
+    """Installing tempest-cli must be enough to run the ruff commands.
+
+    Six of the eight commands are ruff. Reading the requirement from the
+    installed distribution, not from ``pyproject.toml``, is what proves
+    a user actually receives it.
+    """
+    from importlib.metadata import requires
+
+    declared = requires("tempest-cli") or []
+    runtime = [item for item in declared if "extra ==" not in item]
+    assert any(item.startswith("ruff") for item in runtime), runtime
+    assert not any(item.startswith(("mypy", "pytest")) for item in runtime), runtime

{tempest_cli-0.2.0 → tempest_cli-0.3.0}/uv.lock

@@ -1126,9 +1126,10 @@ wheels = [
 
 [[package]]
 name = "tempest-cli"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
+    { name = "ruff" },
     { name = "typer" },
 ]
 
@@ -1136,7 +1137,6 @@ dependencies = [
 tools = [
     { name = "mypy" },
     { name = "pytest" },
-    { name = "ruff" },
 ]
 
 [package.dev-dependencies]
@@ -1156,7 +1156,7 @@ docs = [
 requires-dist = [
     { name = "mypy", marker = "extra == 'tools'", specifier = ">=1.13.0" },
     { name = "pytest", marker = "extra == 'tools'", specifier = ">=8.3.3" },
-    { name = "ruff", marker = "extra == 'tools'", specifier = ">=0.8.0" },
+    { name = "ruff", specifier = ">=0.8.0" },
     { name = "typer", specifier = ">=0.12.0" },
 ]
 provides-extras = ["tools"]

tempest_cli-0.2.0/docs/installation.md

@@ -1,89 +0,0 @@
-# Instalação
-
-```bash
-uv add --dev tempest-cli
-```
-
-Ou com pip:
-
-```bash
-pip install tempest-cli
-```
-
-Requer **Python 3.11+**. A única dependência de runtime é o `typer`.
-
-Ficam instalados **dois executáveis**: `tempest-cli` e o apelido curto
-`tc`. São o mesmo programa — tudo nesta documentação vale para os dois.
-
-```bash
-tc check        # idêntico a tempest-cli check
-```
-
-!!! warning "`tc` também é o `tc(8)` do iproute2"
-    Enquanto o ambiente que instalou o pacote estiver no `PATH`, `tc`
-    resolve para esta CLI. Para o controlador de tráfego do Linux, chame
-    pelo caminho absoluto (`/usr/sbin/tc`) ou use `tempest-cli` e deixe
-    o `tc` livre.
-
-## De onde vêm o ruff, o mypy e o pytest
-
-O `tempest-cli` **não** fixa versão de nenhum dos três: ele executa o que
-encontrar, nesta ordem:
-
-1. **o ambiente da execução** — o diretório do interpretador que está
-   rodando a CLI (onde o extra `[tools]` instala as três), depois
-   `$VIRTUAL_ENV`, depois o `.venv` mais próximo subindo a árvore;
-2. **o `PATH`** — pulando um *shim* de gerenciador de versão que não
-   despacha para lugar nenhum (veja abaixo);
-3. **`uv run --with <ferramenta> <ferramenta>`**, quando o `uv` está
-   disponível — o ambiente do projeto mais a ferramenta, sem exigir
-   ativação nem `uv sync` prévio.
-
-Se nada resolver, o comando sai com **127** e diz qual ferramenta faltou
-e como instalá-la, em vez de estourar um traceback.
-
-!!! info "Por que o `PATH` não vem primeiro"
-    Em máquina com pyenv/asdf, o diretório `shims` está no `PATH`
-    globalmente e tem um stub para toda ferramenta que qualquer versão
-    instalada já forneceu. Procurar `ruff` ali acha
-    `~/.pyenv/shims/ruff` mesmo quando o projeto não tem ruff nenhum — e
-    rodá-lo dá `pyenv: ruff: command not found`. Por isso o ambiente da
-    execução ganha do `PATH`, e um shim só é aceito depois de provar que
-    despacha (`<ferramenta> --version` saindo `0`).
-
-!!! tip "Por que não fixar as versões"
-    Uma versão de ruff fixada aqui viraria o teto de todo projeto que
-    instalasse este pacote — e atualizar o linter é decisão de quem
-    escreve o código, não de quem empacota o gate.
-
-Se você prefere instalar as três junto:
-
-```bash
-uv add --dev "tempest-cli[tools]"
-```
-
-## Verificando
-
-```bash
-tempest-cli --version
-tc --version          # o mesmo programa
-tempest-cli check --help
-```
-
-## Em CI
-
-Cada comando devolve o código de saída da ferramenta por baixo, então o
-job lê exatamente como leria o `ruff` direto:
-
-```yaml
-- name: Quality gate
-  run: uv run tempest-cli check
-```
-
-## Recap
-
-- `uv add --dev tempest-cli`, Python 3.11+, só o `typer` de dependência.
-- Dois executáveis: `tempest-cli` e o apelido `tc`.
-- As ferramentas vêm do ambiente da execução, do `PATH` (sem shim morto)
-  ou do `uv run --with`.
-- Ferramenta ausente = saída 127 com mensagem, não traceback.