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

readability_cli-0.10.2/README.md → readability_cli-0.10.4/PKG-INFO

@@ -1,3 +1,18 @@
+Metadata-Version: 2.5
+Name: readability-cli
+Version: 0.10.4
+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
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: click>=8.3.1
+Provides-Extra: sync
+Requires-Dist: beautifulsoup4>=4.14.3; extra == 'sync'
+Requires-Dist: markdownify>=1.2.2; extra == 'sync'
+Requires-Dist: requests>=2.33.0; extra == 'sync'
+Description-Content-Type: text/markdown
+
 # Readability
 
 A CLI tool that keeps code aligned with Google style conventions. It runs the
@@ -9,7 +24,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 +100,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 +108,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 +118,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 +137,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 +193,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 +204,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
@@ -354,9 +373,13 @@ Supported languages and their aliases:
   - vim [cached]
 ```
 
-Refresh the cache with `sync`, which takes languages or refetches everything:
+Refresh the cache with `sync`, which takes languages or refetches everything.
+It fetches and converts HTML, so it needs the `sync` extra; the bundled guides
+are already converted, and every other command reads those:
 
 ```bash
+pip install 'readability-cli[sync]'
+
 # Refetch one guide, or a few
 readability sync python shell
 
@@ -371,8 +394,8 @@ The tool stores local copies of the style guides in the
 the `guide` command uses these local files when they exist. The bundled copies
 are automatically synchronized weekly from the official
 [Google Style Guides](https://google.github.io/styleguide/) repository via
-GitHub Actions, and you can refresh your local cache at any time with the `sync`
-command.
+GitHub Actions, so upgrading the package is usually enough. To refresh a local
+cache yourself, install the `sync` extra and run the `sync` command.
 
 You can override the default guide directory by setting the
 `READABILITY_CACHE` environment variable. This is useful if you want to store

readability_cli-0.10.2/PKG-INFO → readability_cli-0.10.4/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.5
-Name: readability-cli
-Version: 0.10.2
-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
-License-File: LICENSE
-Requires-Python: >=3.12
-Requires-Dist: beautifulsoup4>=4.14.3
-Requires-Dist: click>=8.3.1
-Requires-Dist: markdownify>=1.2.2
-Requires-Dist: requests>=2.33.0
-Description-Content-Type: text/markdown
-
 # Readability
 
 A CLI tool that keeps code aligned with Google style conventions. It runs the
@@ -23,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
@@ -98,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
 
@@ -106,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
@@ -114,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`.
@@ -133,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:
 
@@ -189,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.
@@ -199,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
@@ -368,9 +358,13 @@ Supported languages and their aliases:
   - vim [cached]
 ```
 
-Refresh the cache with `sync`, which takes languages or refetches everything:
+Refresh the cache with `sync`, which takes languages or refetches everything.
+It fetches and converts HTML, so it needs the `sync` extra; the bundled guides
+are already converted, and every other command reads those:
 
 ```bash
+pip install 'readability-cli[sync]'
+
 # Refetch one guide, or a few
 readability sync python shell
 
@@ -385,8 +379,8 @@ The tool stores local copies of the style guides in the
 the `guide` command uses these local files when they exist. The bundled copies
 are automatically synchronized weekly from the official
 [Google Style Guides](https://google.github.io/styleguide/) repository via
-GitHub Actions, and you can refresh your local cache at any time with the `sync`
-command.
+GitHub Actions, so upgrading the package is usually enough. To refresh a local
+cache yourself, install the `sync` extra and run the `sync` command.
 
 You can override the default guide directory by setting the
 `READABILITY_CACHE` environment variable. This is useful if you want to store

{readability_cli-0.10.2 → readability_cli-0.10.4}/pyproject.toml

@@ -1,12 +1,17 @@
 [project]
 name = "readability-cli"
-version = "0.10.2"
+version = "0.10.4"
 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"
 dependencies = [
-    "beautifulsoup4>=4.14.3",
     "click>=8.3.1",
+]
+
+# Only `sync` fetches and converts guides; the rest reads bundled copies.
+[project.optional-dependencies]
+sync = [
+    "beautifulsoup4>=4.14.3",
     "markdownify>=1.2.2",
     "requests>=2.33.0",
 ]
@@ -34,6 +39,8 @@ testpaths = ["."]
 [dependency-groups]
 dev = [
     "pytest>=9.0.2",
+    # The suite and the weekly guide refresh both exercise `sync`.
+    "readability-cli[sync]",
     "ruff>=0.15.8",
 ]
 
@@ -41,7 +48,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.4}/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.4}/readability/cli.py

@@ -12,6 +12,7 @@ from readability.guide import get_guide
 from readability.guide import get_guides_dir
 from readability.guide import get_local_path
 from readability.guide import LANGUAGE_MAP
+from readability.guide import load_sync_deps
 from readability.guide import refresh_guide
 from readability.outline import _echo_outline
 from readability.outline import _select_section
@@ -123,6 +124,9 @@ def sync(languages: Sequence[str], verbose: bool) -> None:
     if verbose:
         logger.setLevel(logging.DEBUG)
 
+    # A precondition, not a per-guide failure the loop should report N times
+    load_sync_deps()
+
     filenames = _resolve_filenames(languages)
     click.echo(f"Synchronizing {len(filenames)} style guide(s)...", err=True)
 
@@ -147,6 +151,10 @@ def sync(languages: Sequence[str], verbose: bool) -> None:
         err=True,
     )
 
+    # A guide that did not refetch leaves a stale local copy behind
+    if failure_count:
+        sys.exit(1)
+
 
 def _echo_languages() -> None:
     """Print the languages that have a guide, with their aliases."""
@@ -240,7 +248,6 @@ def check(paths: Sequence[str], fix: bool, unsafe: bool, verbose: bool) -> None:
     )
 
 
-# Main entry point for the CLI
 def main() -> None:
     """Main entry point for the CLI."""
     # Configured here, not at import, so library use has no side effects

{readability_cli-0.10.2 → readability_cli-0.10.4}/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.4}/readability/guide.py

@@ -1,21 +1,46 @@
 """Fetch and cache Google style guides."""
 
+import functools
 from importlib.resources import files
 import logging
 import os
+import types
 import warnings
 
-from bs4 import BeautifulSoup
-from bs4 import XMLParsedAsHTMLWarning
 import click
-from markdownify import markdownify as md
-import requests
-
-warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)
 
 logger = logging.getLogger("readability")
 
 
+@functools.cache
+def load_sync_deps() -> tuple[
+    types.ModuleType, types.ModuleType, types.ModuleType
+]:
+    """Imports the libraries only the guide refresh needs.
+
+    Guides ship pre-converted, so this stack stays out of the default
+    install rather than charging every user for `sync`.
+
+    Returns:
+        The requests, bs4, and markdownify modules.
+
+    Raises:
+        click.ClickException: If the sync extra is not installed.
+    """
+    try:
+        import bs4  # noqa: PLC0415
+        import markdownify  # noqa: PLC0415
+        import requests  # noqa: PLC0415
+    except ImportError as e:
+        raise click.ClickException(
+            "Refreshing style guides needs extra libraries. Install them "
+            "with: pip install 'readability-cli[sync]'"
+        ) from e
+
+    warnings.filterwarnings("ignore", category=bs4.XMLParsedAsHTMLWarning)
+    return requests, bs4, markdownify
+
+
 def get_guides_dir() -> str:
     """Get the directory where style guides are cached.
 
@@ -29,7 +54,6 @@ def get_guides_dir() -> str:
     return os.getenv("READABILITY_CACHE") or str(bundled_guides)
 
 
-# Mapping of languages to their Google Style Guide file paths
 LANGUAGE_MAP = {
     "python": "pyguide.md",
     "shell": "shellguide.md",
@@ -72,9 +96,9 @@ def get_guide_content(url: str) -> str:
     Raises:
         click.ClickException: If the HTTP request fails.
     """
+    requests, _, _ = load_sync_deps()
     logger.info("Fetching style guide from %s", url)
 
-    # Perform the HTTP GET request with a timeout
     try:
         response = requests.get(url, timeout=10)
         response.raise_for_status()
@@ -82,7 +106,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
 
@@ -97,9 +121,9 @@ def convert_to_markdown(content: str, filename: str) -> str:
     Returns:
         The converted markdown content.
     """
+    _, bs4, markdownify = load_sync_deps()
     logger.debug("Converting content for %s", filename)
 
-    # Handle Markdown files directly
     if filename.endswith(".md"):
         return content
 
@@ -107,11 +131,10 @@ def convert_to_markdown(content: str, filename: str) -> str:
     if content.lstrip().startswith("<?xml"):
         content = content.split("?>", 1)[-1].lstrip()
 
-    # Handle XML files (used for Vim script guide and JSON style guide)
+    # The Vim script and JSON guides are only published as XML
     if filename.endswith(".xml"):
-        soup = BeautifulSoup(content, "html.parser")
+        soup = bs4.BeautifulSoup(content, "html.parser")
 
-        # Add titles as headers
         guide = soup.find("guide")
         if guide:
             title = guide.get("title")
@@ -136,11 +159,10 @@ def convert_to_markdown(content: str, filename: str) -> str:
 
         for summary in soup.find_all("summary"):
             summary.name = "p"
-            # Wrap content in strong tags
             content_str = summary.decode_contents()
             summary.clear()
             strong = soup.new_tag("strong")
-            strong.append(BeautifulSoup(content_str, "html.parser"))
+            strong.append(bs4.BeautifulSoup(content_str, "html.parser"))
             summary.append(strong)
 
         for snippet in soup.find_all(["code_snippet", "bad_code_snippet"]):
@@ -157,14 +179,11 @@ def convert_to_markdown(content: str, filename: str) -> str:
                 snippet.append(p)
             snippet.append(code)
 
-        # Convert the modified soup to string and then to markdown
-        return md(str(soup), **MARKDOWNIFY_OPTIONS)
+        return markdownify.markdownify(str(soup), **MARKDOWNIFY_OPTIONS)
 
-    # Handle HTML files by converting them to Markdown
     if filename.endswith(".html"):
-        return md(content, **MARKDOWNIFY_OPTIONS)
+        return markdownify.markdownify(content, **MARKDOWNIFY_OPTIONS)
 
-    # Fallback to returning raw content
     return content
 
 
@@ -181,9 +200,7 @@ def get_local_path(filename: str) -> str:
     Returns:
         The full local path to the cached markdown file.
     """
-    # Flatten the filename by replacing '/' with '-'
     flattened = filename.replace("/", "-")
-    # Use the flattened filename and change extension to .md for uniform storage
     base_name = flattened.rsplit(".", 1)[0]
     return os.path.join(get_guides_dir(), f"{base_name}.md")
 
@@ -227,7 +244,6 @@ def get_guide(language: str, remote: bool = False) -> str:
     Raises:
         click.UsageError: If the language is not supported.
     """
-    # Look up the filename in the mapping
     filename = LANGUAGE_MAP.get(language.lower())
     if not filename:
         error_msg = f"Language '{language}' is not supported."
@@ -239,10 +255,9 @@ def get_guide(language: str, remote: bool = False) -> str:
 
     local_path = get_local_path(filename)
 
-    # 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.4}/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.4}/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.4}/test_outline.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from unittest.mock import MagicMock
 from unittest.mock import patch
 
+import click
 from click.testing import CliRunner
 
 from readability.cli import cli
@@ -523,7 +524,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
 
@@ -787,6 +788,21 @@ def test_sync_deduplicates_aliases(
     assert mock_get_content.call_count == 1
 
 
+@patch("readability.guide.get_guide_content")
+def test_sync_reports_a_failed_fetch_in_its_exit_code(
+    mock_get_content: MagicMock, tmp_path: Path
+) -> None:
+    """A stale local copy left behind is a failure, not a quiet success."""
+    mock_get_content.side_effect = click.ClickException("network is down")
+
+    with patch("readability.guide.get_guides_dir", return_value=str(tmp_path)):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["sync", "python"])
+
+    assert result.exit_code != 0
+    assert "Failures: 1" in result.stderr
+
+
 def test_sync_rejects_an_unsupported_language(tmp_path: Path) -> None:
     """An unknown language is a typo, not a reason to sync everything."""
     with patch("readability.guide.get_guides_dir", return_value=str(tmp_path)):

{readability_cli-0.10.2 → readability_cli-0.10.4}/uv.lock

@@ -194,11 +194,15 @@ wheels = [
 
 [[package]]
 name = "readability-cli"
-version = "0.10.2"
+version = "0.10.4"
 source = { editable = "." }
 dependencies = [
-    { name = "beautifulsoup4" },
     { name = "click" },
+]
+
+[package.optional-dependencies]
+sync = [
+    { name = "beautifulsoup4" },
     { name = "markdownify" },
     { name = "requests" },
 ]
@@ -206,20 +210,23 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "pytest" },
+    { name = "readability-cli", extra = ["sync"] },
     { name = "ruff" },
 ]
 
 [package.metadata]
 requires-dist = [
-    { name = "beautifulsoup4", specifier = ">=4.14.3" },
+    { name = "beautifulsoup4", marker = "extra == 'sync'", specifier = ">=4.14.3" },
     { name = "click", specifier = ">=8.3.1" },
-    { name = "markdownify", specifier = ">=1.2.2" },
-    { name = "requests", specifier = ">=2.33.0" },
+    { name = "markdownify", marker = "extra == 'sync'", specifier = ">=1.2.2" },
+    { name = "requests", marker = "extra == 'sync'", specifier = ">=2.33.0" },
 ]
+provides-extras = ["sync"]
 
 [package.metadata.requires-dev]
 dev = [
     { name = "pytest", specifier = ">=9.0.2" },
+    { name = "readability-cli", extras = ["sync"] },
     { name = "ruff", specifier = ">=0.15.8" },
 ]