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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: readability-cli
-Version: 0.10.2
+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
@@ -98,7 +99,7 @@ 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, are unaffected by it.
+such as gofmt and goimports, are unaffected by it.
 
 ### Supported Formats
 
@@ -106,7 +107,9 @@ such as gofmt, are unaffected by it.
 | ---------------------------------------------------------------- | --------------------------------------- | ------------------------------------- |
 | `.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
@@ -114,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`.
@@ -133,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:
 
@@ -189,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.
@@ -199,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.2 → 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
@@ -84,7 +85,7 @@ 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, are unaffected by it.
+such as gofmt and goimports, are unaffected by it.
 
 ### Supported Formats
 
@@ -92,7 +93,9 @@ such as gofmt, are unaffected by it.
 | ---------------------------------------------------------------- | --------------------------------------- | ------------------------------------- |
 | `.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
@@ -100,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`.
@@ -119,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:
 
@@ -175,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.
@@ -185,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.2 → readability_cli-0.10.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "readability-cli"
-version = "0.10.2"
+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.2 → readability_cli-0.10.3}/readability/checking.py

@@ -204,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.2 → 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.2 → 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.2 → readability_cli-0.10.3}/readability/tools.py

@@ -347,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
@@ -354,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
@@ -392,6 +408,13 @@ 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
@@ -549,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.2 → 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,
@@ -1608,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(
@@ -1653,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
 
 
@@ -2195,3 +2373,321 @@ def test_unsafe_is_a_no_op_for_tools_without_one(
     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.2 → 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.2 → readability_cli-0.10.3}/uv.lock

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