readability-cli 0.10.1__tar.gz → 0.10.3__tar.gz

{readability_cli-0.10.1 → readability_cli-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: readability-cli
-Version: 0.10.1
+Version: 0.10.3
 Summary: A CLI to lint, format, and type-check code with Google-style defaults, and pull Google style guides in markdown format.
 Project-URL: Homepage, https://github.com/owahltinez/readability
 Project-URL: Repository, https://github.com/owahltinez/readability
@@ -23,7 +23,8 @@ quick access to style conventions without browsing HTML pages.
 ## Features
 
 - **Linting & Formatting**: A `check` command that automatically detects and
-  runs relevant tools (Ruff, Pyrefly, Biome, and gofmt) for your project.
+  runs relevant tools (Ruff, Pyrefly, Biome, gofmt, goimports, shfmt,
+  shellcheck, and rustfmt) for your project.
 - **Predictable Ownership**: Every supported format has fixed tools, so
   configuration customizes checks without changing which formatter runs.
 - **Style Guides**: A `guide` command that fetches the latest Google style
@@ -90,15 +91,25 @@ readability check src/ tests/ main.py
 
 # Automatically fix and format files
 readability check . --fix
+
+# Also apply fixes that may change behavior (implies --fix)
+readability check . --unsafe
 ```
 
+Fixes that may change a program's behavior or drop its comments are opt-in
+through `--unsafe`, which every tool applies under its own name: Ruff's
+`--unsafe-fixes` and Biome's `--unsafe`. Tools drawing no such distinction,
+such as gofmt and goimports, are unaffected by it.
+
 ### Supported Formats
 
 | Formats                                                          | Owners                                  | Project configuration                 |
 | ---------------------------------------------------------------- | --------------------------------------- | ------------------------------------- |
 | `.py`                                                            | Ruff lint/format; Pyrefly type checking | Ruff and Pyrefly native configuration |
 | `.js`, `.jsx`, `.ts`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | Biome                                   | `biome.json` or `biome.jsonc`         |
-| `.go`                                                            | gofmt                                   | None                                  |
+| `.go`                                                            | gofmt, goimports                        | None                                  |
+| `.sh`, `.bash`                                                   | shfmt format; shellcheck lint           | None                                  |
+| `.rs`                                                            | rustfmt                                 | None                                  |
 
 Markdown, YAML, SCSS, JSONL, and extensions not listed above are unsupported.
 An unsupported-only path reports that nothing was checked and exits
@@ -106,8 +117,8 @@ successfully.
 
 Biome first checks a project's `node_modules/.bin`. Ruff, Pyrefly, and Biome
 then use `PATH`, followed by `uvx` for the Python tools or `npx` for Biome. The
-runners cache downloads, so subsequent runs work offline. Gofmt ships with Go
-and must be available on `PATH`.
+runners cache downloads, so subsequent runs work offline. Gofmt and goimports
+must be available on `PATH`.
 
 That keeps this package at ~4 MB rather than the ~54 MB it would take to carry
 Ruff and Pyrefly itself — a cost that would fall on everyone using only `guide`.
@@ -125,8 +136,8 @@ Set `UV_OFFLINE=1` to forbid fetching. A tool that then cannot be reached fails
 the run rather than passing it.
 
 Ruff, Pyrefly, and Biome ship with bundled configurations, so they run on every
-file they own without project setup. Gofmt runs on `.go` files even when there
-is no `go.mod`.
+file they own without project setup. Gofmt and goimports run on `.go` files even
+when there is no `go.mod`.
 
 A tool that could not be reached at all is never skipped quietly:
 
@@ -181,8 +192,9 @@ caller happened to be standing in.
 Ruff and Pyrefly defaults follow the
 [Google Python style guide](https://google.github.io/styleguide/pyguide.html):
 80-column lines, Google docstrings, one import per line sorted as isort's
-`google` profile does, and full type checking. The Biome default applies the
-80-column lines and two-space indentation of the
+`google` profile does, best-practice lint rules (bugbear, pyupgrade, simplify,
+comprehensions, and Ruff-specific rules), and full type checking. The Biome
+default applies the 80-column lines and two-space indentation of the
 [Google JavaScript style guide](https://google.github.io/styleguide/jsguide.html)
 and enables Biome's recommended lint rules. Project `biome.json` and
 `biome.jsonc` files replace those bundled defaults for Biome-owned formats.
@@ -191,9 +203,9 @@ For Python, add `[tool.ruff]` or `[tool.pyrefly]` to `pyproject.toml`, or use
 `ruff.toml`, `.ruff.toml`, or `pyrefly.toml`. Ruff, Pyrefly, and Biome load
 their native project configurations in place of bundled defaults. Readability
 does not interpret EditorConfig itself; a canonical tool such as Biome may opt
-into it through that tool's native configuration. Gofmt has no project settings.
-The bundled Biome file requires Biome 2.5 or later, matching the fallback
-runner's version floor.
+into it through that tool's native configuration. Neither gofmt nor goimports
+has project settings. The bundled Biome file requires Biome 2.5 or later,
+matching the fallback runner's version floor.
 
 Configuration is found per file, in the file's own directory and then its
 ancestors, which is where each canonical tool looks. A package keeping its

{readability_cli-0.10.1 → readability_cli-0.10.3}/README.md

@@ -9,7 +9,8 @@ quick access to style conventions without browsing HTML pages.
 ## Features
 
 - **Linting & Formatting**: A `check` command that automatically detects and
-  runs relevant tools (Ruff, Pyrefly, Biome, and gofmt) for your project.
+  runs relevant tools (Ruff, Pyrefly, Biome, gofmt, goimports, shfmt,
+  shellcheck, and rustfmt) for your project.
 - **Predictable Ownership**: Every supported format has fixed tools, so
   configuration customizes checks without changing which formatter runs.
 - **Style Guides**: A `guide` command that fetches the latest Google style
@@ -76,15 +77,25 @@ readability check src/ tests/ main.py
 
 # Automatically fix and format files
 readability check . --fix
+
+# Also apply fixes that may change behavior (implies --fix)
+readability check . --unsafe
 ```
 
+Fixes that may change a program's behavior or drop its comments are opt-in
+through `--unsafe`, which every tool applies under its own name: Ruff's
+`--unsafe-fixes` and Biome's `--unsafe`. Tools drawing no such distinction,
+such as gofmt and goimports, are unaffected by it.
+
 ### Supported Formats
 
 | Formats                                                          | Owners                                  | Project configuration                 |
 | ---------------------------------------------------------------- | --------------------------------------- | ------------------------------------- |
 | `.py`                                                            | Ruff lint/format; Pyrefly type checking | Ruff and Pyrefly native configuration |
 | `.js`, `.jsx`, `.ts`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | Biome                                   | `biome.json` or `biome.jsonc`         |
-| `.go`                                                            | gofmt                                   | None                                  |
+| `.go`                                                            | gofmt, goimports                        | None                                  |
+| `.sh`, `.bash`                                                   | shfmt format; shellcheck lint           | None                                  |
+| `.rs`                                                            | rustfmt                                 | None                                  |
 
 Markdown, YAML, SCSS, JSONL, and extensions not listed above are unsupported.
 An unsupported-only path reports that nothing was checked and exits
@@ -92,8 +103,8 @@ successfully.
 
 Biome first checks a project's `node_modules/.bin`. Ruff, Pyrefly, and Biome
 then use `PATH`, followed by `uvx` for the Python tools or `npx` for Biome. The
-runners cache downloads, so subsequent runs work offline. Gofmt ships with Go
-and must be available on `PATH`.
+runners cache downloads, so subsequent runs work offline. Gofmt and goimports
+must be available on `PATH`.
 
 That keeps this package at ~4 MB rather than the ~54 MB it would take to carry
 Ruff and Pyrefly itself — a cost that would fall on everyone using only `guide`.
@@ -111,8 +122,8 @@ Set `UV_OFFLINE=1` to forbid fetching. A tool that then cannot be reached fails
 the run rather than passing it.
 
 Ruff, Pyrefly, and Biome ship with bundled configurations, so they run on every
-file they own without project setup. Gofmt runs on `.go` files even when there
-is no `go.mod`.
+file they own without project setup. Gofmt and goimports run on `.go` files even
+when there is no `go.mod`.
 
 A tool that could not be reached at all is never skipped quietly:
 
@@ -167,8 +178,9 @@ caller happened to be standing in.
 Ruff and Pyrefly defaults follow the
 [Google Python style guide](https://google.github.io/styleguide/pyguide.html):
 80-column lines, Google docstrings, one import per line sorted as isort's
-`google` profile does, and full type checking. The Biome default applies the
-80-column lines and two-space indentation of the
+`google` profile does, best-practice lint rules (bugbear, pyupgrade, simplify,
+comprehensions, and Ruff-specific rules), and full type checking. The Biome
+default applies the 80-column lines and two-space indentation of the
 [Google JavaScript style guide](https://google.github.io/styleguide/jsguide.html)
 and enables Biome's recommended lint rules. Project `biome.json` and
 `biome.jsonc` files replace those bundled defaults for Biome-owned formats.
@@ -177,9 +189,9 @@ For Python, add `[tool.ruff]` or `[tool.pyrefly]` to `pyproject.toml`, or use
 `ruff.toml`, `.ruff.toml`, or `pyrefly.toml`. Ruff, Pyrefly, and Biome load
 their native project configurations in place of bundled defaults. Readability
 does not interpret EditorConfig itself; a canonical tool such as Biome may opt
-into it through that tool's native configuration. Gofmt has no project settings.
-The bundled Biome file requires Biome 2.5 or later, matching the fallback
-runner's version floor.
+into it through that tool's native configuration. Neither gofmt nor goimports
+has project settings. The bundled Biome file requires Biome 2.5 or later,
+matching the fallback runner's version floor.
 
 Configuration is found per file, in the file's own directory and then its
 ancestors, which is where each canonical tool looks. A package keeping its

{readability_cli-0.10.1 → readability_cli-0.10.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "readability-cli"
-version = "0.10.1"
+version = "0.10.3"
 description = "A CLI to lint, format, and type-check code with Google-style defaults, and pull Google style guides in markdown format."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -41,7 +41,7 @@ dev = [
 line-length = 80
 
 [tool.ruff.lint]
-select = ["E", "W", "F", "I", "N", "D", "PL"]
+select = ["E", "W", "F", "I", "N", "D", "PL", "B", "UP", "SIM", "C4", "RUF"]
 ignore = ["PLR0911", "PLR0912", "PLR0913", "PLR0915", "PLR2004"]
 
 [tool.ruff.lint.pydocstyle]

{readability_cli-0.10.1 → readability_cli-0.10.3}/readability/checking.py

@@ -62,6 +62,7 @@ def check_paths(
     paths: Sequence[str | Path],
     project_root: Path | None = None,
     fix: bool = False,
+    unsafe: bool = False,
 ) -> CheckReport:
     """Run relevant checks for paths and aggregate what the tools did.
 
@@ -78,6 +79,8 @@ def check_paths(
             and ignore files. Defaults to the repository the process is in.
             It does not rebase paths.
         fix: Whether to apply automatic fixes.
+        unsafe: Whether those fixes may change behavior or drop comments.
+            Tools that draw no such distinction are unaffected.
 
     Returns:
         A report aggregated across all provided paths.
@@ -100,7 +103,7 @@ def check_paths(
 
     report = CheckReport()
     for path in requested_paths:
-        path_report = _check_path(path, root, boundary, fix=fix)
+        path_report = _check_path(path, root, boundary, fix=fix, unsafe=unsafe)
         if not path_report.ran:
             path_report.unverified_paths.append(path)
         report.absorb(path_report)
@@ -112,6 +115,7 @@ def _check_path(
     project_root: Path,
     boundary: Path | None = None,
     fix: bool = False,
+    unsafe: bool = False,
 ) -> CheckReport:
     """Apply relevant tools to a single path.
 
@@ -121,6 +125,7 @@ def _check_path(
         boundary: Outermost directory config discovery may consider, or
             None to bound it by the path's own repository.
         fix: Whether to apply automatic fixes.
+        unsafe: Whether those fixes may change behavior or drop comments.
 
     Returns:
         What the tools applicable to this path did.
@@ -141,7 +146,7 @@ def _check_path(
             report.skipped.add(tool.name)
             continue
 
-        report.absorb(_run_tool(tool, fix=fix))
+        report.absorb(_run_tool(tool, fix=fix, unsafe=unsafe))
 
     return report
 
@@ -149,12 +154,14 @@ def _check_path(
 def _run_tool(
     tool: ToolPlan,
     fix: bool = False,
+    unsafe: bool = False,
 ) -> CheckReport:
     """Orchestrate the execution of a specific formatting or linting tool.
 
     Args:
         tool: The executable plan to run.
         fix: Whether to apply automatic fixes.
+        unsafe: Whether those fixes may change behavior or drop comments.
 
     Returns:
         What the tool did: whether it reported findings, and whether it
@@ -168,9 +175,11 @@ def _run_tool(
     target_count = len(tool.targets or ())
     try:
         if fix:
+            # A tool with no unsafe mode still fixes what it safely can
+            unsafe_fix = tool.unsafe_fix if unsafe else ()
+            phases = (("format", tool.format), ("fix", unsafe_fix or tool.fix))
             # Leftovers exit non-zero, which is a finding rather than a failure
-            for phase in ("format", "fix"):
-                configured_command = getattr(tool, phase)
+            for phase, configured_command in phases:
                 if configured_command:
                     commands = _command_batches(
                         configured_command, target_count
@@ -195,9 +204,10 @@ def _run_tool(
                 result = _capture_tool_command(command, cwd=tool.cwd)
                 if _tool_checked_files(tool.name, result):
                     report.ran.add(tool.name)
-                # gofmt reports by naming files rather than by exit code
+                # gofmt and goimports name files rather than using exit codes
                 if result.returncode != 0 or (
-                    tool.name == "gofmt" and result.stdout.strip()
+                    tool.name in ("gofmt", "goimports")
+                    and result.stdout.strip()
                 ):
                     report.findings = True
                     click.echo(

{readability_cli-0.10.1 → readability_cli-0.10.3}/readability/cli.py

@@ -167,8 +167,13 @@ def _echo_languages() -> None:
 @click.option(
     "--fix", is_flag=True, help="Automatically fix issues if possible."
 )
+@click.option(
+    "--unsafe",
+    is_flag=True,
+    help="Also apply fixes that may change behavior. Implies --fix.",
+)
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging.")
-def check(paths: Sequence[str], fix: bool, verbose: bool) -> None:
+def check(paths: Sequence[str], fix: bool, unsafe: bool, verbose: bool) -> None:
     """Run relevant formatters and linters for given paths.
 
     Exits with a non-zero status code if any tool reports findings, so the
@@ -177,7 +182,8 @@ def check(paths: Sequence[str], fix: bool, verbose: bool) -> None:
     if verbose:
         logger.setLevel(logging.DEBUG)
 
-    report = check_paths(paths, fix=fix)
+    # Unsafe fixes are still fixes, so asking for them is asking to fix
+    report = check_paths(paths, fix=fix or unsafe, unsafe=unsafe)
 
     # Coverage the caller does not know is missing reads as coverage
     if report.skipped:

{readability_cli-0.10.1 → readability_cli-0.10.3}/readability/configs/ruff.toml

@@ -6,8 +6,9 @@ line-length = 80
 
 [lint]
 # Pycodestyle (E, W), Pyflakes (F), import order (I), naming (N),
-# docstrings (D), and pylint (PL) rules
-select = ["E", "W", "F", "I", "N", "D", "PL"]
+# docstrings (D), pylint (PL), bugbear (B), pyupgrade (UP),
+# simplify (SIM), comprehensions (C4), and ruff-specific (RUF) rules
+select = ["E", "W", "F", "I", "N", "D", "PL", "B", "UP", "SIM", "C4", "RUF"]
 # Complexity counters and magic-value warnings are guidance, not errors
 ignore = ["PLR0911", "PLR0912", "PLR0913", "PLR0915", "PLR2004"]
 

{readability_cli-0.10.1 → readability_cli-0.10.3}/readability/guide.py

@@ -82,7 +82,7 @@ def get_guide_content(url: str) -> str:
         logger.error("Failed to fetch content from %s: %s", url, e)
         raise click.ClickException(
             f"Failed to fetch style guide from {url}: {e}"
-        )
+        ) from e
 
     return response.text
 
@@ -242,7 +242,7 @@ def get_guide(language: str, remote: bool = False) -> str:
     # If remote is False, check for local file first
     if not remote and os.path.exists(local_path):
         logger.info("Reading style guide from local file: %s", local_path)
-        with open(local_path, "r", encoding="utf-8") as f:
+        with open(local_path, encoding="utf-8") as f:
             return f.read()
 
     return refresh_guide(filename)

{readability_cli-0.10.1 → readability_cli-0.10.3}/readability/tools.py

@@ -21,6 +21,7 @@ class ToolPlan:
     check: tuple[str, ...] = ()
     check_format: tuple[str, ...] = ()
     fix: tuple[str, ...] = ()
+    unsafe_fix: tuple[str, ...] = ()
     format: tuple[str, ...] = ()
     targets: tuple[str, ...] | None = None
     cwd: Path | None = None
@@ -300,10 +301,16 @@ def _plan(
             for exclude in excludes
             for argument in (str(flag), str(exclude))
         ]
+    # Every tool spells its own opt-in, so callers only ask for the intent
+    words_by_phase: dict[str, tuple[str, ...]] = dict(TOOL_PHASES[tool])
+    unsafe_flag = UNSAFE_FLAGS.get(tool)
+    if unsafe_flag and "fix" in words_by_phase:
+        words_by_phase["unsafe_fix"] = (*words_by_phase["fix"], unsafe_flag)
+
     # Named rather than unpacked, so the type checker still sees the fields
     phases = {
         phase: (*binary, *words, *config, *carved, *argv)
-        for phase, words in TOOL_PHASES[tool].items()
+        for phase, words in words_by_phase.items()
     }
     return ToolPlan(
         name=tool,
@@ -313,6 +320,7 @@ def _plan(
         check=phases.get("check", ()),
         check_format=phases.get("check_format", ()),
         fix=phases.get("fix", ()),
+        unsafe_fix=phases.get("unsafe_fix", ()),
         format=phases.get("format", ()),
     )
 
@@ -339,6 +347,10 @@ TOOL_EXTENSIONS = {
         ".html",
     ),
     "gofmt": (".go",),
+    "goimports": (".go",),
+    "shfmt": (".sh", ".bash"),
+    "shellcheck": (".sh", ".bash"),
+    "rustfmt": (".rs",),
 }
 
 # Headroom below common argv limits; long target lists are split before exec
@@ -346,8 +358,20 @@ MAX_COMMAND_BYTES = 16 * 1024
 
 # Named files bypass a tool's own exclusions, and Pyrefly ignores its excludes
 PRUNED_DIRECTORIES = frozenset(
-    ".git .hg .svn .venv venv .tox .nox node_modules "
-    "__pycache__ .mypy_cache .pytest_cache .ruff_cache".split()
+    [
+        ".git",
+        ".hg",
+        ".svn",
+        ".venv",
+        "venv",
+        ".tox",
+        ".nox",
+        "node_modules",
+        "__pycache__",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+    ]
 )
 
 # Per tool: config filenames, pyproject section (None if it has none), flag
@@ -384,8 +408,18 @@ TOOL_PHASES = {
         "format": ("format", "--write", "--no-errors-on-unmatched"),
     },
     "gofmt": {"check_format": ("-l",), "format": ("-w",)},
+    "goimports": {"check_format": ("-l",), "format": ("-w",)},
+    "shfmt": {
+        "check_format": ("-i", "2", "-ci", "-d"),
+        "format": ("-i", "2", "-ci", "-w"),
+    },
+    "shellcheck": {"check": ()},
+    "rustfmt": {"check_format": ("--check",), "format": ()},
 }
 
+# Per tool: how it names fixes that may change behavior or drop comments
+UNSAFE_FLAGS = {"ruff": "--unsafe-fixes", "biome": "--unsafe"}
+
 
 def _matching_paths(path: Path, extensions: Sequence[str]) -> list[str]:
     """Return files under a requested path owned by one tool.
@@ -538,6 +572,42 @@ def _get_tool_definitions(
             path,
         )
     )
+    plans.append(
+        _plan(
+            "goimports",
+            ("goimports",),
+            [],
+            _matching_paths(path, TOOL_EXTENSIONS["goimports"]),
+            path,
+        )
+    )
+    plans.append(
+        _plan(
+            "shfmt",
+            ("shfmt",),
+            [],
+            _matching_paths(path, TOOL_EXTENSIONS["shfmt"]),
+            path,
+        )
+    )
+    plans.append(
+        _plan(
+            "shellcheck",
+            ("shellcheck",),
+            [],
+            _matching_paths(path, TOOL_EXTENSIONS["shellcheck"]),
+            path,
+        )
+    )
+    plans.append(
+        _plan(
+            "rustfmt",
+            ("rustfmt",),
+            [],
+            _matching_paths(path, TOOL_EXTENSIONS["rustfmt"]),
+            path,
+        )
+    )
 
     # A directory owning its config alone lets Pyrefly select the files
     files, section = CONFIG_SOURCES["pyrefly"][:2]

{readability_cli-0.10.1 → readability_cli-0.10.3}/test_checking.py

@@ -15,6 +15,8 @@ from readability.cli import cli
 from readability.tools import _bundled_config
 from readability.tools import _get_tool_definitions
 from readability.tools import _has_project_config
+from readability.tools import TOOL_EXTENSIONS
+from readability.tools import TOOL_PHASES
 from readability.tools import TOOL_RUNNERS
 
 
@@ -1045,6 +1047,17 @@ def test_bundled_default_configs_are_valid() -> None:
     }
 
 
+def test_bundled_ruff_config_includes_enriched_rules() -> None:
+    """The default ruff config selects best-practice and modernization rules."""
+    # Enriched rules for bug prevention, modern syntax, and simplification
+    ruff_config = tomllib.loads(_bundled_config("ruff").read_text())
+    selected_rules = set(ruff_config["lint"]["select"])
+    expected_rules = {"B", "UP", "SIM", "C4", "RUF"}
+
+    # All enriched rule sets must be present
+    assert expected_rules.issubset(selected_rules)
+
+
 @patch("readability.checking._check_path")
 def test_check_paths_aggregates_str_and_path_inputs(
     mock_check_path: MagicMock,
@@ -1080,8 +1093,16 @@ def test_check_paths_aggregates_str_and_path_inputs(
         failed={"biome"},
     )
     assert mock_check_path.call_args_list == [
-        call(Path("src/example.py"), project_root, project_root, fix=True),
-        call(Path("main.go"), project_root, project_root, fix=True),
+        call(
+            Path("src/example.py"),
+            project_root,
+            project_root,
+            fix=True,
+            unsafe=False,
+        ),
+        call(
+            Path("main.go"), project_root, project_root, fix=True, unsafe=False
+        ),
     ]
 
 
@@ -1128,7 +1149,7 @@ def test_check_paths_defaults_project_root_to_cwd(
     check_paths([Path("example.py")])
 
     mock_check_path.assert_called_once_with(
-        Path("example.py"), tmp_path, None, fix=False
+        Path("example.py"), tmp_path, None, fix=False, unsafe=False
     )
 
 
@@ -1197,7 +1218,9 @@ def test_check_command_delegates_to_public_api(
         Path("script.py").touch()
         result = runner.invoke(cli, ["check", "script.py"])
 
-    mock_check_paths.assert_called_once_with(("script.py",), fix=False)
+    mock_check_paths.assert_called_once_with(
+        ("script.py",), fix=False, unsafe=False
+    )
     assert result.exit_code == 0
     assert result.stdout == ""
     assert result.stderr == "No findings in 1 path(s) (ruff).\n"
@@ -1598,6 +1621,170 @@ def test_gofmt_fix_failure_is_reported(
     assert "gofmt formatting findings" in result.output
 
 
+def test_goimports_tool_plan_generation(tmp_path: Path) -> None:
+    """Go files produce goimports plans alongside gofmt."""
+    go_file = tmp_path / "main.go"
+    go_file.touch()
+
+    # Verify tool registration in extensions and phases
+    assert TOOL_EXTENSIONS["goimports"] == (".go",)
+    assert TOOL_PHASES["goimports"] == {
+        "check_format": ("-l",),
+        "format": ("-w",),
+    }
+
+    # Verify tool plan creation
+    plans = {
+        plan.name: plan for plan in _get_tool_definitions(go_file, tmp_path)
+    }
+    assert "goimports" in plans
+    goimports = plans["goimports"]
+    assert goimports.extensions == (".go",)
+    assert goimports.check_format == ("goimports", "-l", str(go_file))
+    assert goimports.format == ("goimports", "-w", str(go_file))
+    assert goimports.check == ()
+    assert goimports.fix == ()
+    assert goimports.targets == (str(go_file),)
+
+
+@pytest.mark.parametrize("fix", (False, True))
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_configless_go_uses_goimports_for_check_and_fix(
+    mock_run: MagicMock,
+    mock_which: MagicMock,
+    tmp_path: Path,
+    fix: bool,
+) -> None:
+    """Standalone Go files use symmetric goimports commands without go.mod."""
+    mock_which.side_effect = lambda name: name if name == "goimports" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Run check or format on Go file
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.go").touch()
+        arguments = ["check", "main.go"]
+        if fix:
+            arguments.append("--fix")
+
+        result = runner.invoke(cli, arguments)
+
+    # Verify goimports command invoked with correct flags
+    assert result.exit_code == 0
+    expected = ["goimports", "-w" if fix else "-l", "main.go"]
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        expected
+    ]
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_goimports_scopes_a_directory_to_go_files(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Goimports receives recursive Go files instead of an invalid directory."""
+    mock_which.side_effect = lambda name: name if name == "goimports" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Populate directory structure with mixed files
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("src/nested").mkdir(parents=True)
+        Path("src/main.go").touch()
+        Path("src/nested/helper.go").touch()
+        Path("src/notes.txt").touch()
+
+        result = runner.invoke(cli, ["check", "src"])
+
+    # Verify only Go files are passed to goimports
+    assert result.exit_code == 0
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["goimports", "-l", "src/main.go", "src/nested/helper.go"]
+    ]
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_goimports_check_reports_diff_in_stdout_as_findings(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Goimports reports diffs on stdout while exiting zero."""
+    mock_which.side_effect = lambda name: name if name == "goimports" else None
+    mock_run.return_value = MagicMock(
+        returncode=0, stdout="main.go\n", stderr=""
+    )
+
+    # Invoke check on unformatted Go file
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.go").touch()
+
+        result = runner.invoke(cli, ["check", "main.go"])
+
+    # Findings in stdout must fail the check
+    assert result.exit_code == 1
+    assert "--- goimports formatting findings ---" in result.output
+    assert "main.go" in result.output
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_goimports_fix_failure_is_reported(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A failed goimports write cannot be reported as a clean fix."""
+    mock_which.side_effect = lambda name: name if name == "goimports" else None
+    mock_run.return_value = MagicMock(
+        returncode=1, stdout="", stderr="invalid Go syntax"
+    )
+
+    # Invoke check --fix on invalid Go file
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.go").touch()
+
+        result = runner.invoke(cli, ["check", "main.go", "--fix"])
+
+    # Fix error must fail the check
+    assert result.exit_code == 1
+    assert "goimports formatting findings" in result.output
+
+
+@pytest.mark.parametrize("fix", (False, True))
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_go_runs_both_gofmt_and_goimports(
+    mock_run: MagicMock,
+    mock_which: MagicMock,
+    tmp_path: Path,
+    fix: bool,
+) -> None:
+    """When both gofmt and goimports are installed, both run on Go files."""
+    mock_which.side_effect = lambda name: (
+        name if name in ("gofmt", "goimports") else None
+    )
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Run check or fix with both Go tools available
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.go").touch()
+        arguments = ["check", "main.go"]
+        if fix:
+            arguments.append("--fix")
+
+        result = runner.invoke(cli, arguments)
+
+    # Verify both tools ran with the appropriate flag
+    assert result.exit_code == 0
+    flag = "-w" if fix else "-l"
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["gofmt", flag, "main.go"],
+        ["goimports", flag, "main.go"],
+    ]
+
+
 @patch("shutil.which")
 @patch("subprocess.run")
 def test_large_biome_directory_uses_bounded_commands(
@@ -1643,6 +1830,7 @@ def test_missing_gofmt_is_reported_for_configless_go(
 
     assert result.exit_code == 1
     assert "gofmt" in result.stderr
+    assert "goimports" in result.stderr
     assert "nothing was verified" in result.stderr
 
 
@@ -2052,3 +2240,454 @@ def test_fix_still_reports_what_it_could_not_fix(
     commands = [call.args[0] for call in mock_run.call_args_list]
     assert any("--fix" not in c and "check" in c for c in commands)
     assert result.exit_code != 0
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_unsafe_translates_to_the_ruff_flag(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """--unsafe reaches ruff under the name ruff gives it.
+
+    Args:
+        mock_run: The mocked subprocess.run function.
+        mock_which: The mocked shutil.which function.
+        tmp_path: The temporary directory fixture.
+    """
+    mock_which.side_effect = lambda name: name if name == "ruff" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("pyproject.toml").touch()
+        Path("script.py").touch()
+
+        result = runner.invoke(cli, ["check", "--fix", "--unsafe", "script.py"])
+
+    assert result.exit_code == 0
+    cfg = str(_bundled_config("ruff"))
+    called_cmds = [call.args[0] for call in mock_run.call_args_list]
+    assert [
+        "ruff",
+        "check",
+        "--fix",
+        "--force-exclude",
+        "--unsafe-fixes",
+        "--config",
+        cfg,
+        "script.py",
+    ] in called_cmds
+    # Formatters have no unsafe mode, so the flag must not reach them
+    assert [
+        "ruff",
+        "format",
+        "--force-exclude",
+        "--config",
+        cfg,
+        "script.py",
+    ] in called_cmds
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_unsafe_translates_to_the_biome_flag(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Biome spells the same intent differently and gets its own spelling.
+
+    Args:
+        mock_run: The mocked subprocess.run function.
+        mock_which: The mocked shutil.which function.
+        tmp_path: The temporary directory fixture.
+    """
+    mock_which.side_effect = lambda name: name if name == "biome" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.ts").touch()
+
+        result = runner.invoke(cli, ["check", "--fix", "--unsafe", "script.ts"])
+
+    assert result.exit_code == 0
+    called_cmds = [call.args[0] for call in mock_run.call_args_list]
+    lint = next(c for c in called_cmds if "lint" in c)
+    assert lint[:5] == [
+        "biome",
+        "lint",
+        "--write",
+        "--no-errors-on-unmatched",
+        "--unsafe",
+    ]
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_unsafe_implies_fix(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Asking for unsafe fixes without --fix asks for nothing otherwise.
+
+    Args:
+        mock_run: The mocked subprocess.run function.
+        mock_which: The mocked shutil.which function.
+        tmp_path: The temporary directory fixture.
+    """
+    mock_which.side_effect = lambda name: name if name == "ruff" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("pyproject.toml").touch()
+        Path("script.py").touch()
+
+        result = runner.invoke(cli, ["check", "--unsafe", "script.py"])
+
+    assert result.exit_code == 0
+    called_cmds = [call.args[0] for call in mock_run.call_args_list]
+    assert any("--unsafe-fixes" in command for command in called_cmds)
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_unsafe_is_a_no_op_for_tools_without_one(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A tool with no unsafe mode still fixes rather than being skipped.
+
+    Args:
+        mock_run: The mocked subprocess.run function.
+        mock_which: The mocked shutil.which function.
+        tmp_path: The temporary directory fixture.
+    """
+    mock_which.side_effect = lambda name: name if name == "gofmt" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.go").touch()
+
+        result = runner.invoke(cli, ["check", "--fix", "--unsafe", "main.go"])
+
+    assert result.exit_code == 0
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["gofmt", "-w", "main.go"]
+    ]
+
+
+@pytest.mark.parametrize("extension", (".sh", ".bash"))
+def test_tool_definitions_for_shell(extension: str, tmp_path: Path) -> None:
+    """Shell files yield shfmt and shellcheck plans with style arguments."""
+    # Create the target shell file
+    script = tmp_path / f"script{extension}"
+    script.touch()
+
+    # Resolve tool plans for the file
+    tools = {
+        tool.name: tool for tool in _get_tool_definitions(script, tmp_path)
+    }
+
+    # Verify shfmt plan
+    shfmt = tools["shfmt"]
+    assert shfmt.extensions == (".sh", ".bash")
+    assert shfmt.check_format == ("shfmt", "-i", "2", "-ci", "-d", str(script))
+    assert shfmt.format == ("shfmt", "-i", "2", "-ci", "-w", str(script))
+    assert shfmt.check == ()
+    assert shfmt.fix == ()
+
+    # Verify shellcheck plan
+    shellcheck = tools["shellcheck"]
+    assert shellcheck.extensions == (".sh", ".bash")
+    assert shellcheck.check == ("shellcheck", str(script))
+    assert shellcheck.check_format == ()
+    assert shellcheck.format == ()
+    assert shellcheck.fix == ()
+
+
+def test_tool_definitions_for_rust(tmp_path: Path) -> None:
+    """Rust files yield rustfmt plans with check and in-place formatting."""
+    # Create the target Rust file
+    source = tmp_path / "main.rs"
+    source.touch()
+
+    # Resolve tool plans for the file
+    tools = {
+        tool.name: tool for tool in _get_tool_definitions(source, tmp_path)
+    }
+
+    # Verify rustfmt plan
+    rustfmt = tools["rustfmt"]
+    assert rustfmt.extensions == (".rs",)
+    assert rustfmt.check_format == ("rustfmt", "--check", str(source))
+    assert rustfmt.format == ("rustfmt", str(source))
+    assert rustfmt.check == ()
+    assert rustfmt.fix == ()
+
+
+@pytest.mark.parametrize("extension", (".sh", ".bash"))
+@pytest.mark.parametrize("fix", (False, True))
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_shell_uses_shfmt_and_shellcheck_for_check_and_fix(
+    mock_run: MagicMock,
+    mock_which: MagicMock,
+    tmp_path: Path,
+    extension: str,
+    fix: bool,
+) -> None:
+    """Shell files invoke shfmt and shellcheck during check and fix."""
+    # Allow shfmt and shellcheck to appear installed
+    mock_which.side_effect = lambda name: (
+        name if name in ("shfmt", "shellcheck") else None
+    )
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Run check command in an isolated environment
+    runner = CliRunner()
+    filename = f"script{extension}"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path(filename).touch()
+        arguments = ["check", filename]
+        if fix:
+            arguments.append("--fix")
+        result = runner.invoke(cli, arguments)
+
+    # Verify clean exit and expected tool invocations
+    assert result.exit_code == 0
+    shfmt_action = "-w" if fix else "-d"
+    expected = [
+        ["shfmt", "-i", "2", "-ci", shfmt_action, filename],
+        ["shellcheck", filename],
+    ]
+    assert [
+        invocation.args[0] for invocation in mock_run.call_args_list
+    ] == expected
+
+
+@pytest.mark.parametrize("fix", (False, True))
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_rust_uses_rustfmt_for_check_and_fix(
+    mock_run: MagicMock,
+    mock_which: MagicMock,
+    tmp_path: Path,
+    fix: bool,
+) -> None:
+    """Rust files invoke rustfmt with check flag or in-place format."""
+    # Allow rustfmt to appear installed
+    mock_which.side_effect = lambda name: name if name == "rustfmt" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Run check command in an isolated environment
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.rs").touch()
+        arguments = ["check", "main.rs"]
+        if fix:
+            arguments.append("--fix")
+        result = runner.invoke(cli, arguments)
+
+    # Verify clean exit and expected tool invocations
+    assert result.exit_code == 0
+    expected = (
+        [["rustfmt", "main.rs"]] if fix else [["rustfmt", "--check", "main.rs"]]
+    )
+    assert [
+        invocation.args[0] for invocation in mock_run.call_args_list
+    ] == expected
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_shell_tools_scope_a_directory_to_shell_files(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Shell tools only receive shell files under checked directories."""
+    # Allow shfmt and shellcheck to appear installed
+    mock_which.side_effect = lambda name: (
+        name if name in ("shfmt", "shellcheck") else None
+    )
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Populate directory with shell and non-shell files
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("src/nested").mkdir(parents=True)
+        Path("src/script.sh").touch()
+        Path("src/nested/setup.bash").touch()
+        Path("src/notes.txt").touch()
+        result = runner.invoke(cli, ["check", "src"])
+
+    # Verify tool calls are scoped to matching files
+    assert result.exit_code == 0
+    expected_files = ["src/nested/setup.bash", "src/script.sh"]
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["shfmt", "-i", "2", "-ci", "-d", *expected_files],
+        ["shellcheck", *expected_files],
+    ]
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_rustfmt_scopes_a_directory_to_rust_files(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Rustfmt only receives Rust files under checked directories."""
+    # Allow rustfmt to appear installed
+    mock_which.side_effect = lambda name: name if name == "rustfmt" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Populate directory with Rust and non-Rust files
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("src/nested").mkdir(parents=True)
+        Path("src/main.rs").touch()
+        Path("src/nested/lib.rs").touch()
+        Path("src/notes.txt").touch()
+        result = runner.invoke(cli, ["check", "src"])
+
+    # Verify tool calls are scoped to matching files
+    assert result.exit_code == 0
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["rustfmt", "--check", "src/main.rs", "src/nested/lib.rs"]
+    ]
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_shfmt_formatting_findings_reported(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Non-zero exit from shfmt diff is reported as a formatting finding."""
+    # Allow shfmt to appear installed
+    mock_which.side_effect = lambda name: (
+        name if name in ("shfmt", "shellcheck") else None
+    )
+    mock_run.side_effect = [
+        MagicMock(
+            returncode=1, stdout="--- script.sh\n+++ script.sh\n", stderr=""
+        ),
+        MagicMock(returncode=0, stdout="", stderr=""),
+    ]
+
+    # Run check command
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.sh").touch()
+        result = runner.invoke(cli, ["check", "script.sh"])
+
+    # Verify exit code and finding output
+    assert result.exit_code == 1
+    assert "shfmt formatting findings" in result.output
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_shellcheck_findings_reported(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Non-zero exit from shellcheck is reported as findings."""
+    # Allow shellcheck to appear installed
+    mock_which.side_effect = lambda name: (
+        name if name in ("shfmt", "shellcheck") else None
+    )
+    mock_run.side_effect = [
+        MagicMock(returncode=0, stdout="", stderr=""),
+        MagicMock(
+            returncode=1,
+            stdout="SC2086: Double quote to prevent globbing",
+            stderr="",
+        ),
+    ]
+
+    # Run check command
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.sh").touch()
+        result = runner.invoke(cli, ["check", "script.sh"])
+
+    # Verify exit code and finding output
+    assert result.exit_code == 1
+    assert "shellcheck findings" in result.output
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_rustfmt_formatting_findings_reported(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Non-zero exit from rustfmt check is reported as a formatting finding."""
+    # Allow rustfmt to appear installed
+    mock_which.side_effect = lambda name: name if name == "rustfmt" else None
+    mock_run.return_value = MagicMock(
+        returncode=1, stdout="Diff in main.rs", stderr=""
+    )
+
+    # Run check command
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.rs").touch()
+        result = runner.invoke(cli, ["check", "main.rs"])
+
+    # Verify exit code and finding output
+    assert result.exit_code == 1
+    assert "rustfmt formatting findings" in result.output
+
+
+@patch("shutil.which", return_value=None)
+def test_missing_shell_tools_reported(
+    mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Missing shell tools leave shell files unverified."""
+    # Run check command with missing tools
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.sh").touch()
+        result = runner.invoke(cli, ["check", "script.sh"])
+
+    # Verify error message and exit code
+    assert result.exit_code == 1
+    assert "shfmt" in result.stderr
+    assert "shellcheck" in result.stderr
+    assert "nothing was verified" in result.stderr
+
+
+@patch("shutil.which", return_value=None)
+def test_missing_rustfmt_reported(
+    mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Missing rustfmt leaves Rust files unverified."""
+    # Run check command with missing rustfmt
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("main.rs").touch()
+        result = runner.invoke(cli, ["check", "main.rs"])
+
+    # Verify error message and exit code
+    assert result.exit_code == 1
+    assert "rustfmt" in result.stderr
+    assert "nothing was verified" in result.stderr
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_partial_shell_tools_installed_warns_and_runs_installed(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A lone installed shell tool runs and warns that the other is absent."""
+    # Only shfmt is installed
+    mock_which.side_effect = lambda name: name if name == "shfmt" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    # Run check command
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.sh").touch()
+        result = runner.invoke(cli, ["check", "script.sh"])
+
+    # Verify shfmt ran, shellcheck was skipped with warning, exit code 0
+    assert result.exit_code == 0
+    assert "shellcheck" in result.stderr
+    assert [invocation.args[0] for invocation in mock_run.call_args_list] == [
+        ["shfmt", "-i", "2", "-ci", "-d", "script.sh"]
+    ]

{readability_cli-0.10.1 → readability_cli-0.10.3}/test_outline.py

@@ -523,7 +523,7 @@ def _shipped_guides() -> list[tuple[str, str]]:
         if filename in seen or not os.path.exists(path):
             continue
         seen.add(filename)
-        with open(path, "r", encoding="utf-8") as f:
+        with open(path, encoding="utf-8") as f:
             guides.append((language, f.read()))
     return guides
 

{readability_cli-0.10.1 → readability_cli-0.10.3}/uv.lock

@@ -194,7 +194,7 @@ wheels = [
 
 [[package]]
 name = "readability-cli"
-version = "0.10.1"
+version = "0.10.3"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },