readability-cli 0.8.1__tar.gz → 0.8.3__tar.gz

{readability_cli-0.8.1 → readability_cli-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: readability-cli
-Version: 0.8.1
+Version: 0.8.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
@@ -24,8 +24,9 @@ and quick access to style conventions without browsing HTML pages.
 
 - **Linting & Formatting**: A `check` command that automatically detects and
   runs relevant tools (Ruff, Pyrefly, Biome, Prettier, gofmt) for your project.
-- **Sensible Defaults**: Bundled Google-style configurations for Ruff and
-  Pyrefly are used automatically when a project does not define its own.
+- **Sensible Defaults**: Bundled Google-style configurations for Ruff,
+  Pyrefly, and Biome are used automatically when a project does not define its
+  own.
 - **Style Guides**: A `guide` command that fetches the latest Google style
   guides (Python, Shell, C++, Java, JS/TS, Go, etc.) converted to Markdown,
   and outlines, addresses, and searches them by section rather than serving
@@ -98,7 +99,7 @@ readability check . --fix
 |------|----------------------|---------------|------------|
 | **Ruff** | `.py` | none, bundled | `uvx` |
 | **Pyrefly** | `.py` | none, bundled | `uvx` |
-| **Biome** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | `biome.json` or `biome.jsonc` | `npx` |
+| **Biome** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | none, bundled | `npx` |
 | **Prettier** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.css`, `.scss`, `.html`, `.md`, `.yml`, `.yaml` | `.prettierrc*` or `prettier.config.*` | `npx` |
 | **gofmt** | `.go` | `go.mod` | — |
 
@@ -123,10 +124,9 @@ always wins over a fetched one.
 Set `UV_OFFLINE=1` to forbid fetching. A tool that then cannot be reached
 fails the run rather than passing it.
 
-Ruff and Pyrefly ship with bundled configurations, so they run on any file
-they handle without the project arranging anything. Biome, Prettier and gofmt
-bring no defaults here, so they wait until the project asks with a config
-file.
+Ruff, Pyrefly, and Biome ship with bundled configurations, so they run on any
+file they handle without the project arranging anything. Prettier and gofmt
+bring no defaults here, so they wait until the project asks with a config file.
 
 A tool that could not be reached at all is never skipped quietly:
 
@@ -144,8 +144,10 @@ Error: Every tool for 1 path(s) is missing, so nothing was verified.
 That second case needs neither the tool nor a runner to be present, which is
 the state a container image is usually in.
 
-`check` exits non-zero on findings and on having verified nothing, so it can
-gate CI without a clean exit ever meaning "the tools were absent".
+`check` exits non-zero on findings, tool failures, and when every applicable
+tool is absent, so it can gate CI without a clean exit meaning required tools
+were missing. If no tool applies to the requested paths, it reports that fact
+and exits successfully.
 
 ### Python API
 
@@ -164,17 +166,26 @@ if report.findings or report.failed or not report.ran:
 
 The returned `CheckReport` records only whether findings occurred and which
 tools ran, were skipped, or failed. Detailed tool findings are still written
-as each tool runs.
+as each tool runs. Every path is validated before any tool runs, and a missing
+one raises `FileNotFoundError` rather than being misreported as a finding.
+Relative paths remain relative to the process working directory;
+`project_root` controls configuration discovery only.
 
 ### Default Configurations
 
-For Ruff and Pyrefly, bundled defaults based on the
-[Google Python style guide](https://google.github.io/styleguide/pyguide.html)
-(80-column lines, Google docstring convention, import ordering, full type
-checking) are applied when the project does not define its own configuration.
-To override them, add a `[tool.ruff]` or `[tool.pyrefly]` section to your
-`pyproject.toml` (or a dedicated `ruff.toml` / `pyrefly.toml`) — any
-project-level configuration takes full precedence over the bundled defaults.
+Ruff and Pyrefly defaults follow the
+[Google Python style guide](https://google.github.io/styleguide/pyguide.html):
+80-column lines, Google docstrings, import ordering, 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. These defaults apply only when the
+project does not define its own configuration. To override them, add a
+`[tool.ruff]` or `[tool.pyrefly]` section to your `pyproject.toml`, or a
+dedicated `ruff.toml`, `pyrefly.toml`, `biome.json`, or `biome.jsonc` — any
+project-level configuration takes full precedence. The bundled Biome file
+intentionally uses only settings supported by both Biome 1.x and 2.x, so a
+project-local installation remains authoritative without creating a schema
+mismatch.
 
 ## Style Guides
 

{readability_cli-0.8.1 → readability_cli-0.8.3}/README.md

@@ -10,8 +10,9 @@ and quick access to style conventions without browsing HTML pages.
 
 - **Linting & Formatting**: A `check` command that automatically detects and
   runs relevant tools (Ruff, Pyrefly, Biome, Prettier, gofmt) for your project.
-- **Sensible Defaults**: Bundled Google-style configurations for Ruff and
-  Pyrefly are used automatically when a project does not define its own.
+- **Sensible Defaults**: Bundled Google-style configurations for Ruff,
+  Pyrefly, and Biome are used automatically when a project does not define its
+  own.
 - **Style Guides**: A `guide` command that fetches the latest Google style
   guides (Python, Shell, C++, Java, JS/TS, Go, etc.) converted to Markdown,
   and outlines, addresses, and searches them by section rather than serving
@@ -84,7 +85,7 @@ readability check . --fix
 |------|----------------------|---------------|------------|
 | **Ruff** | `.py` | none, bundled | `uvx` |
 | **Pyrefly** | `.py` | none, bundled | `uvx` |
-| **Biome** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | `biome.json` or `biome.jsonc` | `npx` |
+| **Biome** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.jsonc`, `.css`, `.html` | none, bundled | `npx` |
 | **Prettier** | `.js`, `.ts`, `.jsx`, `.tsx`, `.json`, `.css`, `.scss`, `.html`, `.md`, `.yml`, `.yaml` | `.prettierrc*` or `prettier.config.*` | `npx` |
 | **gofmt** | `.go` | `go.mod` | — |
 
@@ -109,10 +110,9 @@ always wins over a fetched one.
 Set `UV_OFFLINE=1` to forbid fetching. A tool that then cannot be reached
 fails the run rather than passing it.
 
-Ruff and Pyrefly ship with bundled configurations, so they run on any file
-they handle without the project arranging anything. Biome, Prettier and gofmt
-bring no defaults here, so they wait until the project asks with a config
-file.
+Ruff, Pyrefly, and Biome ship with bundled configurations, so they run on any
+file they handle without the project arranging anything. Prettier and gofmt
+bring no defaults here, so they wait until the project asks with a config file.
 
 A tool that could not be reached at all is never skipped quietly:
 
@@ -130,8 +130,10 @@ Error: Every tool for 1 path(s) is missing, so nothing was verified.
 That second case needs neither the tool nor a runner to be present, which is
 the state a container image is usually in.
 
-`check` exits non-zero on findings and on having verified nothing, so it can
-gate CI without a clean exit ever meaning "the tools were absent".
+`check` exits non-zero on findings, tool failures, and when every applicable
+tool is absent, so it can gate CI without a clean exit meaning required tools
+were missing. If no tool applies to the requested paths, it reports that fact
+and exits successfully.
 
 ### Python API
 
@@ -150,17 +152,26 @@ if report.findings or report.failed or not report.ran:
 
 The returned `CheckReport` records only whether findings occurred and which
 tools ran, were skipped, or failed. Detailed tool findings are still written
-as each tool runs.
+as each tool runs. Every path is validated before any tool runs, and a missing
+one raises `FileNotFoundError` rather than being misreported as a finding.
+Relative paths remain relative to the process working directory;
+`project_root` controls configuration discovery only.
 
 ### Default Configurations
 
-For Ruff and Pyrefly, bundled defaults based on the
-[Google Python style guide](https://google.github.io/styleguide/pyguide.html)
-(80-column lines, Google docstring convention, import ordering, full type
-checking) are applied when the project does not define its own configuration.
-To override them, add a `[tool.ruff]` or `[tool.pyrefly]` section to your
-`pyproject.toml` (or a dedicated `ruff.toml` / `pyrefly.toml`) — any
-project-level configuration takes full precedence over the bundled defaults.
+Ruff and Pyrefly defaults follow the
+[Google Python style guide](https://google.github.io/styleguide/pyguide.html):
+80-column lines, Google docstrings, import ordering, 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. These defaults apply only when the
+project does not define its own configuration. To override them, add a
+`[tool.ruff]` or `[tool.pyrefly]` section to your `pyproject.toml`, or a
+dedicated `ruff.toml`, `pyrefly.toml`, `biome.json`, or `biome.jsonc` — any
+project-level configuration takes full precedence. The bundled Biome file
+intentionally uses only settings supported by both Biome 1.x and 2.x, so a
+project-local installation remains authoritative without creating a schema
+mismatch.
 
 ## Style Guides
 

readability_cli-0.8.3/configs/biome-default.json

@@ -0,0 +1,14 @@
+{
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 80
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  }
+}

{readability_cli-0.8.1 → readability_cli-0.8.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "readability-cli"
-version = "0.8.1"
+version = "0.8.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"

{readability_cli-0.8.1 → readability_cli-0.8.3}/readability.py

@@ -1116,6 +1116,11 @@ def check(paths: Sequence[str], fix: bool, verbose: bool) -> None:
         )
         sys.exit(1)
 
+    # Findings remain a failed check even when a tool reports that it could
+    # not process any files (for example, a Biome configuration error).
+    if report.findings:
+        sys.exit(1)
+
     # Having run nothing is not a pass. Reporting it as one is how this
     # command became a silent no-op wherever its tools were absent, gating
     # nothing while every caller read the exit code as approval.
@@ -1137,13 +1142,19 @@ def check(paths: Sequence[str], fix: bool, verbose: bool) -> None:
         )
         return
 
-    if report.findings:
-        sys.exit(1)
+    checked_path_count = len(paths) - len(report.unverified_paths)
+    if report.unverified_paths:
+        click.echo(
+            f"Warning: nothing was checked for "
+            f"{len(report.unverified_paths)} path(s): "
+            f"{', '.join(map(str, report.unverified_paths))}.",
+            err=True,
+        )
 
     # Findings are the only thing this command printed, so a clean run said
     # nothing at all and left the caller unable to tell it from a no-op.
     click.echo(
-        f"No findings in {len(paths)} path(s) "
+        f"No findings in {checked_path_count} path(s) "
         f"({', '.join(sorted(report.ran))}).",
         err=True,
     )
@@ -1155,21 +1166,25 @@ class CheckReport:
 
     Attributes:
         findings: Whether any tool that ran reported something.
-        ran: Names of the tools that completed at least one process. This
-            records what happened, not what was intended: a tool that
-            resolved but never started belongs in failed, or a check that
-            verified nothing reports itself as clean.
+        ran: Names of the tools that processed at least one file. This records
+            what happened, not what was intended. A tool that resolved but
+            never started belongs in failed, and a tool that explicitly
+            reported processing no files is not recorded as having run.
         skipped: Names of the tools that were applicable but not installed.
             Tools with no trigger file are in neither set: they were never
             wanted, so passing without them is not a gap in coverage.
         failed: Names of the tools that started and could not finish, by
             failing to exec or by running past the timeout.
+        unverified_paths: Requested paths for which no tool processed a file.
+            Keeping these paths through aggregation prevents a checked path
+            from hiding another path that a tool ignored.
     """
 
     findings: bool = False
     ran: set[str] = dataclasses.field(default_factory=set)
     skipped: set[str] = dataclasses.field(default_factory=set)
     failed: set[str] = dataclasses.field(default_factory=set)
+    unverified_paths: list[Path] = dataclasses.field(default_factory=list)
 
     def absorb(self, other: "CheckReport") -> None:
         """Fold another report into this one.
@@ -1181,6 +1196,7 @@ class CheckReport:
         self.ran |= other.ran
         self.skipped |= other.skipped
         self.failed |= other.failed
+        self.unverified_paths.extend(other.unverified_paths)
 
 
 def check_paths(
@@ -1196,18 +1212,33 @@ def check_paths(
     the result.
 
     Args:
-        paths: Files or directories to check, as strings or paths.
-        project_root: Root used to discover tool configuration. Defaults to
-            the current working directory.
+        paths: Files or directories to check, as strings or paths. Relative
+            paths are interpreted from the current working directory.
+        project_root: Root used only to discover tool configuration. Defaults
+            to the current working directory; it does not rebase paths.
         fix: Whether to apply automatic fixes.
 
     Returns:
         A report aggregated across all provided paths.
+
+    Raises:
+        FileNotFoundError: If any requested path does not exist. Every path is
+            validated before any tools run.
     """
     root = Path.cwd() if project_root is None else project_root
+    requested_paths = [Path(path) for path in paths]
+    missing_path = next(
+        (path for path in requested_paths if not path.exists()), None
+    )
+    if missing_path is not None:
+        raise FileNotFoundError(f"Path does not exist: {missing_path}")
+
     report = CheckReport()
-    for path in paths:
-        report.absorb(_check_path(Path(path), root, fix=fix))
+    for path in requested_paths:
+        path_report = _check_path(path, root, fix=fix)
+        if not path_report.ran:
+            path_report.unverified_paths.append(path)
+        report.absorb(path_report)
     return report
 
 
@@ -1266,12 +1297,20 @@ def _should_run_tool(
         (project_root / t).exists() for t in tool["trigger"]
     )
 
-    # For files, also check if the extension matches one of the supported ones
+    # Files must match one of the tool's supported extensions.
     if path.is_file():
         return has_trigger and path.suffix in tool["extensions"]
 
-    # For directories, the existence of a trigger file is sufficient
-    return has_trigger
+    if not has_trigger:
+        return False
+
+    # A directory trigger alone is not evidence that the tool checked a file.
+    # Several tools deliberately exit zero when nothing matches, which would
+    # otherwise turn an unsupported-only tree into a reported clean result.
+    return any(
+        candidate.is_file() and candidate.suffix in tool["extensions"]
+        for candidate in path.rglob("*")
+    )
 
 
 def _tool_is_installed(tool_name: str, tool_config: dict[str, Any]) -> bool:
@@ -1307,12 +1346,15 @@ def _bundled_config(tool_name: str) -> Path:
     """Get the path to the bundled default configuration for a tool.
 
     Args:
-        tool_name: The name of the tool (e.g. "ruff", "pyrefly").
+        tool_name: The name of the tool (e.g. "ruff", "pyrefly", "biome").
 
     Returns:
         The path to the bundled default config file.
     """
-    return Path(__file__).parent / "configs" / f"{tool_name}.toml"
+    filename = (
+        "biome-default.json" if tool_name == "biome" else f"{tool_name}.toml"
+    )
+    return Path(__file__).parent / "configs" / filename
 
 
 def _has_project_config(
@@ -1444,6 +1486,26 @@ def _get_tool_definitions(
     pyrefly_config = _default_config_args(
         project_root, ["pyrefly.toml"], "pyrefly"
     )
+    biome_config = []
+    if not any(
+        (project_root / filename).exists()
+        for filename in ("biome.json", "biome.jsonc")
+    ):
+        biome_config = ["--config-path", str(_bundled_config("biome"))]
+        ignore_files = (
+            project_root / ".gitignore",
+            project_root / ".ignore",
+            project_root / ".git" / "info" / "exclude",
+        )
+        if any(ignore_file.is_file() for ignore_file in ignore_files):
+            biome_config.extend(
+                [
+                    "--vcs-enabled=true",
+                    "--vcs-client-kind=git",
+                    "--vcs-use-ignore-file=true",
+                    f"--vcs-root={project_root}",
+                ]
+            )
 
     # Resolved once so every command for a tool reaches the same executable
     ruff = _tool_command("ruff", project_root)
@@ -1499,12 +1561,14 @@ def _get_tool_definitions(
             "check": [
                 *biome,
                 "lint",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
             "check_format": [
                 *biome,
                 "format",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
@@ -1512,6 +1576,7 @@ def _get_tool_definitions(
                 *biome,
                 "lint",
                 "--write",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
@@ -1519,6 +1584,7 @@ def _get_tool_definitions(
                 *biome,
                 "format",
                 "--write",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
@@ -1610,11 +1676,13 @@ def _run_tool(
             # and report what they could not deal with.
             for phase in ("format", "fix"):
                 if phase in tool_config:
-                    _execute_tool_command(tool_config[phase])
-                    report.ran.add(tool_name)
+                    result = _capture_tool_command(tool_config[phase])
+                    if _tool_checked_files(tool_name, result):
+                        report.ran.add(tool_name)
         elif "check_format" in tool_config:
             result = _capture_tool_command(tool_config["check_format"])
-            report.ran.add(tool_name)
+            if _tool_checked_files(tool_name, result):
+                report.ran.add(tool_name)
             # gofmt reports by naming files rather than by exit code
             if result.returncode != 0 or (
                 tool_name == "go fmt" and result.stdout.strip()
@@ -1627,7 +1695,8 @@ def _run_tool(
 
         if "check" in tool_config:
             result = _capture_tool_command(tool_config["check"])
-            report.ran.add(tool_name)
+            if _tool_checked_files(tool_name, result):
+                report.ran.add(tool_name)
             if result.returncode != 0:
                 report.findings = True
                 click.echo(
@@ -1644,6 +1713,26 @@ def _run_tool(
     return report
 
 
+def _tool_checked_files(
+    tool_name: str, result: subprocess.CompletedProcess
+) -> bool:
+    """Report whether a completed command actually processed any files.
+
+    Args:
+        tool_name: The tool whose command completed.
+        result: The completed subprocess.
+
+    Returns:
+        False when Biome explicitly reports that it checked zero files.
+    """
+    if tool_name != "biome":
+        return True
+    output = f"{result.stdout or ''}\n{result.stderr or ''}"
+    # Biome 1.x and 2.x use these summaries for an unmatched target.
+    zero_file_summaries = ("Checked 0 files", "Formatted 0 files")
+    return not any(summary in output for summary in zero_file_summaries)
+
+
 def _capture_tool_command(cmd: list[str]) -> subprocess.CompletedProcess:
     """Run a tool and capture what it said, whatever its exit code.
 
@@ -1651,7 +1740,7 @@ def _capture_tool_command(cmd: list[str]) -> subprocess.CompletedProcess:
         cmd: The command list to execute.
 
     Returns:
-        The completed process, for the caller to read an exit code off.
+        The completed process, including captured output and its exit code.
 
     Raises:
         subprocess.SubprocessError: If the command outlives the timeout.
@@ -1667,25 +1756,6 @@ def _capture_tool_command(cmd: list[str]) -> subprocess.CompletedProcess:
     )
 
 
-def _execute_tool_command(cmd: list[str]) -> None:
-    """Execute a tool command, raising if it exits with a non-zero code.
-
-    Args:
-        cmd: The command list to execute.
-
-    Raises:
-        subprocess.SubprocessError: If the command outlives the timeout.
-        OSError: If the command cannot be started.
-    """
-    logger.debug("Executing: %s", " ".join(cmd))
-    # check=False: a fixer exits non-zero when findings are left over, and
-    # treating that as an error aborted the run before the check that
-    # reports them, so --fix passed on files the plain check failed.
-    subprocess.run(
-        cmd, capture_output=True, check=False, timeout=DEFAULT_TIMEOUT
-    )
-
-
 # Main entry point for the CLI
 def main() -> None:
     """Main entry point for the CLI."""

{readability_cli-0.8.1 → readability_cli-0.8.3}/test_readability.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import os
 import subprocess
@@ -505,15 +506,72 @@ def test_default_configs_omitted_when_project_configured(
     assert "--config" not in tools["ruff"]["format"]
     assert "--config" not in tools["pyrefly"]["check"]
 
+    ts_file = tmp_path / "script.ts"
+    ts_file.touch()
+    (tmp_path / "biome.json").write_text("{}")
+    tools = {t["name"]: t for t in _get_tool_definitions(ts_file, tmp_path)}
+    for command in ("check", "check_format", "fix", "format"):
+        assert "--config-path" not in tools["biome"][command]
 
-def test_bundled_default_configs_are_valid(tmp_path: Path) -> None:
-    """Tests that the bundled default configs exist and parse as TOML."""
-    # Both bundled configs must exist and be valid TOML
+
+def test_biome_bundled_config_is_injected_into_every_command(
+    tmp_path: Path,
+) -> None:
+    """Linting, formatting, and their fix forms share the safe default."""
+    ts_file = tmp_path / "script.ts"
+    ts_file.touch()
+
+    tools = {t["name"]: t for t in _get_tool_definitions(ts_file, tmp_path)}
+    config_path = str(_bundled_config("biome"))
+
+    for command_name in ("check", "check_format", "fix", "format"):
+        command = tools["biome"][command_name]
+        assert command[command.index("--config-path") + 1] == config_path
+        assert "--vcs-enabled=true" not in command
+
+
+@pytest.mark.parametrize(
+    "ignore_file", (".gitignore", ".ignore", ".git/info/exclude")
+)
+def test_biome_bundled_config_respects_project_ignore_files(
+    tmp_path: Path, ignore_file: str
+) -> None:
+    """An external default keeps ignore discovery rooted in the project."""
+    ts_file = tmp_path / "script.ts"
+    ts_file.touch()
+    ignore_path = tmp_path / ignore_file
+    ignore_path.parent.mkdir(parents=True, exist_ok=True)
+    ignore_path.write_text("node_modules/\n")
+
+    tools = {t["name"]: t for t in _get_tool_definitions(ts_file, tmp_path)}
+
+    for command_name in ("check", "check_format", "fix", "format"):
+        command = tools["biome"][command_name]
+        assert "--vcs-enabled=true" in command
+        assert "--vcs-client-kind=git" in command
+        assert "--vcs-use-ignore-file=true" in command
+        assert f"--vcs-root={tmp_path}" in command
+
+
+def test_bundled_default_configs_are_valid() -> None:
+    """Tests that the bundled default configs exist and parse."""
+    # Both Python configs must exist and be valid TOML
     for tool in ("ruff", "pyrefly"):
         config_path = _bundled_config(tool)
         assert config_path.exists()
         tomllib.loads(config_path.read_text())
 
+    biome_config_path = _bundled_config("biome")
+    assert biome_config_path.exists()
+    biome_config = json.loads(biome_config_path.read_text())
+    assert biome_config["formatter"] == {
+        "enabled": True,
+        "indentStyle": "space",
+        "indentWidth": 2,
+        "lineWidth": 80,
+    }
+    assert biome_config["linter"]["rules"]["recommended"] is True
+
     # The ruff defaults follow the Google Python style guide
     ruff_config = tomllib.loads(_bundled_config("ruff").read_text())
     assert ruff_config["line-length"] == 80
@@ -522,10 +580,17 @@ def test_bundled_default_configs_are_valid(tmp_path: Path) -> None:
 
 @patch("readability._check_path")
 def test_check_paths_aggregates_str_and_path_inputs(
-    mock_check_path: MagicMock, tmp_path: Path
+    mock_check_path: MagicMock,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """The public API folds each per-path result into one limited report."""
     project_root = tmp_path / "project"
+    project_root.mkdir()
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "example.py").touch()
+    (tmp_path / "README.md").touch()
+    monkeypatch.chdir(tmp_path)
     mock_check_path.side_effect = [
         CheckReport(ran={"ruff"}, skipped={"pyrefly"}),
         CheckReport(
@@ -553,6 +618,29 @@ def test_check_paths_aggregates_str_and_path_inputs(
     ]
 
 
+@patch("readability._check_path")
+def test_check_paths_preserves_unverified_paths_when_another_path_ran(
+    mock_check_path: MagicMock,
+    tmp_path: Path,
+) -> None:
+    """One checked path must not hide another path that processed no files."""
+    checked = tmp_path / "src"
+    unchecked = tmp_path / "ignored"
+    checked.mkdir()
+    unchecked.mkdir()
+    mock_check_path.side_effect = [
+        CheckReport(ran={"biome"}),
+        CheckReport(),
+    ]
+
+    report = check_paths([checked, unchecked], project_root=tmp_path)
+
+    assert report == CheckReport(
+        ran={"biome"},
+        unverified_paths=[unchecked],
+    )
+
+
 @patch("readability._check_path", return_value=CheckReport(ran={"ruff"}))
 def test_check_paths_defaults_project_root_to_cwd(
     mock_check_path: MagicMock,
@@ -561,6 +649,7 @@ def test_check_paths_defaults_project_root_to_cwd(
 ) -> None:
     """The public API discovers configuration from the caller's directory."""
     monkeypatch.chdir(tmp_path)
+    (tmp_path / "example.py").touch()
 
     check_paths([Path("example.py")])
 
@@ -581,6 +670,23 @@ def test_check_paths_with_no_paths_reports_that_nothing_ran(
     mock_check_path.assert_not_called()
 
 
+@patch("readability._check_path")
+def test_check_paths_rejects_missing_paths_before_dispatch(
+    mock_check_path: MagicMock,
+    tmp_path: Path,
+) -> None:
+    """A missing path prevents partial checks and fixes on earlier paths."""
+    existing = tmp_path / "exists.py"
+    missing = tmp_path / "missing.py"
+    existing.touch()
+
+    with pytest.raises(FileNotFoundError) as excinfo:
+        check_paths([existing, missing], project_root=tmp_path, fix=True)
+
+    assert str(missing) in str(excinfo.value)
+    mock_check_path.assert_not_called()
+
+
 @patch(
     "readability._check_path",
     return_value=CheckReport(
@@ -590,10 +696,15 @@ def test_check_paths_with_no_paths_reports_that_nothing_ran(
     ),
 )
 def test_check_paths_returns_report_without_cli_status_prose(
-    mock_check_path: MagicMock, capsys: pytest.CaptureFixture[str]
+    mock_check_path: MagicMock,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
 ) -> None:
     """Library callers receive report states without CLI policy or summaries."""
-    report = check_paths(["example.py"])
+    path = tmp_path / "example.py"
+    path.touch()
+
+    report = check_paths([path])
 
     assert report.findings is True
     assert report.skipped == {"pyrefly"}
@@ -1759,10 +1870,10 @@ def test_check_runs_bundled_default_tools_without_a_trigger(
 
 @patch("shutil.which")
 @patch("subprocess.run")
-def test_check_still_gates_tools_without_bundled_defaults(
+def test_check_runs_biome_without_a_project_config(
     mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
 ) -> None:
-    """Biome and Prettier have no defaults here, so a project must ask."""
+    """A bundled Biome config covers web files in unconfigured projects."""
     mock_which.side_effect = lambda x: x
     mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
 
@@ -1773,13 +1884,179 @@ def test_check_still_gates_tools_without_bundled_defaults(
         result = runner.invoke(cli, ["check", "script.ts"])
 
     assert result.exit_code == 0
+    called = [call.args[0] for call in mock_run.call_args_list]
+    assert any(command[0] == "biome" for command in called)
+    assert all("prettier" not in command for command in called)
+    config_path = str(_bundled_config("biome"))
+    biome_commands = [command for command in called if command[0] == "biome"]
+    assert biome_commands
+    assert all(
+        command[command.index("--config-path") + 1] == config_path
+        for command in biome_commands
+    )
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_bundled_tools_do_not_claim_an_unsupported_directory(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A zero-file tool run must not turn nothing checked into a clean pass."""
+    mock_which.side_effect = lambda x: x
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("notes.md").touch()
+
+        result = runner.invoke(cli, ["check", "."])
+
+    assert result.exit_code == 0
+    output = result.stdout + result.stderr
+    assert "nothing was checked" in output
+    assert "No findings" not in output
+    mock_run.assert_not_called()
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_biome_zero_file_result_is_not_reported_as_clean(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Ignored matches must not make an unverified directory look clean."""
+    mock_which.side_effect = lambda x: x if x == "biome" else None
+    checked_nothing = MagicMock(
+        returncode=0,
+        stdout="",
+        stderr="Checked 0 files in 1ms. No fixes applied.\n",
+    )
+    formatted_nothing = MagicMock(
+        returncode=0,
+        stdout="Formatted 0 files in 1ms. No fixes applied.\n",
+        stderr="",
+    )
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path(".gitignore").write_text("node_modules/\n")
+        Path("node_modules/example").mkdir(parents=True)
+        Path("node_modules/example/index.js").touch()
+        Path("README.md").touch()
+
+        for extra_args, expected_calls in (([], 2), (["--fix"], 3)):
+            mock_run.side_effect = (
+                [checked_nothing, checked_nothing]
+                if not extra_args
+                else [formatted_nothing, checked_nothing, checked_nothing]
+            )
+            result = runner.invoke(cli, ["check", ".", *extra_args])
+
+            assert result.exit_code == 0
+            output = result.stdout + result.stderr
+            assert "nothing was checked" in output
+            assert "No findings" not in output
+            assert mock_run.call_count == expected_calls
+            mock_run.reset_mock()
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_biome_zero_file_path_is_not_hidden_by_a_checked_path(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A clean aggregate identifies requested paths Biome did not inspect."""
+    mock_which.side_effect = lambda x: x if x == "biome" else None
+    checked_files = MagicMock(returncode=0, stdout="", stderr="")
+    checked_nothing = MagicMock(
+        returncode=0,
+        stdout="Checked 0 files in 1ms. No fixes applied.\n",
+        stderr="",
+    )
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path(".gitignore").write_text("ignored/\n")
+        Path("src").mkdir()
+        Path("src/good.js").touch()
+        Path("ignored").mkdir()
+        Path("ignored/generated.js").touch()
+        mock_run.side_effect = [
+            checked_files,
+            checked_files,
+            checked_nothing,
+            checked_nothing,
+        ]
+
+        result = runner.invoke(cli, ["check", "src", "ignored"])
+
+    assert result.exit_code == 0
+    assert "nothing was checked for 1 path(s): ignored" in result.stderr
+    assert "No findings in 1 path(s) (biome)." in result.stderr
+    assert "No findings in 2 path(s)" not in result.stderr
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_biome_zero_file_failure_still_exits_nonzero(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """A configuration failure must not become a successful no-tool result."""
+    mock_which.side_effect = lambda x: x if x == "biome" else None
+    checked_nothing = MagicMock(
+        returncode=1,
+        stdout="Checked 0 files in 1ms.\nConfiguration error.\n",
+        stderr="",
+    )
+    formatted_nothing = MagicMock(
+        returncode=1,
+        stdout="Formatted 0 files in 1ms.\nConfiguration error.\n",
+        stderr="",
+    )
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("script.ts").touch()
+
+        for extra_args in ([], ["--fix"]):
+            mock_run.side_effect = (
+                [checked_nothing, checked_nothing]
+                if not extra_args
+                else [formatted_nothing, checked_nothing, checked_nothing]
+            )
+            result = runner.invoke(cli, ["check", "script.ts", *extra_args])
+
+            assert result.exit_code == 1
+            output = result.stdout + result.stderr
+            assert "biome findings" in output
+            assert "nothing was checked" not in output
+            mock_run.reset_mock()
+
+
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_bundled_biome_applies_to_a_nested_web_file(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """Directory applicability still finds nested web files."""
+    mock_which.side_effect = lambda x: x if x == "biome" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("src").mkdir()
+        Path("src/script.ts").touch()
+
+        result = runner.invoke(cli, ["check", "."])
+
+    assert result.exit_code == 0
+    assert "No findings in 1 path(s) (biome)." in result.stderr
     called = [call.args[0][0] for call in mock_run.call_args_list]
-    assert "npx" not in called
+    assert called == ["biome", "biome"]
 
 
 @patch("shutil.which")
 @patch("subprocess.run")
-def test_check_without_defaults_respects_its_trigger(
+def test_check_with_project_config_runs_biome(
     mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
 ) -> None:
     """With biome.json present, biome runs as it always did."""

{readability_cli-0.8.1 → readability_cli-0.8.3}/uv.lock

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