readability-cli 0.8.2__tar.gz → 0.8.4__tar.gz

{readability_cli-0.8.2 → readability_cli-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: readability-cli
-Version: 0.8.2
+Version: 0.8.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
@@ -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
 
@@ -171,13 +173,19 @@ Relative paths remain relative to the process working directory;
 
 ### 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.2 → readability_cli-0.8.4}/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
 
@@ -157,13 +159,19 @@ Relative paths remain relative to the process working directory;
 
 ### 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.4/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.2 → readability_cli-0.8.4}/guides/jsoncstyleguide.md

@@ -123,7 +123,7 @@ Property names must conform to the following guidelines:
 
 * Property names should be meaningful names with defined semantics.
 * Property names must be camel-cased, ascii strings.
-* The first character must be a letter, an underscore (\_) or a dollar sign ($).
+* The first character must be a letter, an underscore (_) or a dollar sign ($).
 * Subsequent characters can be a letter, a digit, an underscore, or a dollar sign.
 * Reserved JavaScript keywords should be avoided (A list of reserved JavaScript keywords can be found below).
 

{readability_cli-0.8.2 → readability_cli-0.8.4}/pyproject.toml

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

{readability_cli-0.8.2 → readability_cli-0.8.4}/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(
@@ -1219,7 +1235,10 @@ def check_paths(
 
     report = CheckReport()
     for path in requested_paths:
-        report.absorb(_check_path(path, root, fix=fix))
+        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
 
 
@@ -1278,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:
@@ -1319,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(
@@ -1456,6 +1486,32 @@ def _get_tool_definitions(
     pyrefly_config = _default_config_args(
         project_root, ["pyrefly.toml"], "pyrefly"
     )
+    # An explicit path switches Pyrefly to single-file mode, where the
+    # project's includes, excludes, and project-rooted import resolution are
+    # deliberately ignored. A directory backed by project-owned settings is
+    # a project check, so let Pyrefly discover its files from that config.
+    pyrefly_project_mode = path.is_dir() and not pyrefly_config
+    pyrefly_targets = [] if pyrefly_project_mode else [path_str]
+    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)
@@ -1502,7 +1558,13 @@ def _get_tool_definitions(
         {
             # Type checker only: it reports findings but cannot fix or format
             "name": "pyrefly",
-            "check": [*pyrefly, "check", *pyrefly_config, path_str],
+            "check": [
+                *pyrefly,
+                "check",
+                *pyrefly_config,
+                *pyrefly_targets,
+            ],
+            **({"cwd": project_root} if pyrefly_project_mode else {}),
             "trigger": ["pyproject.toml", "pyrefly.toml"],
             "extensions": [".py"],
         },
@@ -1511,12 +1573,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,
             ],
@@ -1524,6 +1588,7 @@ def _get_tool_definitions(
                 *biome,
                 "lint",
                 "--write",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
@@ -1531,6 +1596,7 @@ def _get_tool_definitions(
                 *biome,
                 "format",
                 "--write",
+                *biome_config,
                 "--no-errors-on-unmatched",
                 path_str,
             ],
@@ -1614,6 +1680,7 @@ def _run_tool(
     logger.info("Running %s...", tool_name)
 
     report = CheckReport()
+    cwd = tool_config.get("cwd")
     try:
         if fix:
             # Formatters rewrite files, fixers apply what they can. Both
@@ -1622,11 +1689,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], cwd=cwd)
+                    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)
+            result = _capture_tool_command(tool_config["check_format"], cwd=cwd)
+            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()
@@ -1638,8 +1707,9 @@ def _run_tool(
                 )
 
         if "check" in tool_config:
-            result = _capture_tool_command(tool_config["check"])
-            report.ran.add(tool_name)
+            result = _capture_tool_command(tool_config["check"], cwd=cwd)
+            if _tool_checked_files(tool_name, result):
+                report.ran.add(tool_name)
             if result.returncode != 0:
                 report.findings = True
                 click.echo(
@@ -1656,14 +1726,38 @@ def _run_tool(
     return report
 
 
-def _capture_tool_command(cmd: list[str]) -> subprocess.CompletedProcess:
+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], cwd: Path | None = None
+) -> subprocess.CompletedProcess:
     """Run a tool and capture what it said, whatever its exit code.
 
     Args:
         cmd: The command list to execute.
+        cwd: Directory in which the tool should run. Defaults to the caller's
+            current working directory.
 
     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.
@@ -1676,25 +1770,7 @@ def _capture_tool_command(cmd: list[str]) -> subprocess.CompletedProcess:
         text=True,
         check=False,
         timeout=DEFAULT_TIMEOUT,
-    )
-
-
-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
+        cwd=cwd,
     )
 
 

{readability_cli-0.8.2 → readability_cli-0.8.4}/test_readability.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import os
 import subprocess
@@ -458,6 +459,36 @@ def test_check_command_pyrefly(
     assert ["pyrefly", "check", "--config", cfg, "script.py"] in called_cmds
 
 
+@patch("shutil.which")
+@patch("subprocess.run")
+def test_check_command_runs_configured_directory_as_pyrefly_project(
+    mock_run: MagicMock, mock_which: MagicMock, tmp_path: Path
+) -> None:
+    """The CLI lets project-owned includes and excludes select Python files."""
+    mock_which.side_effect = lambda name: name if name == "pyrefly" else None
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("pyrefly.toml").write_text(
+            'project-excludes = ["**/excluded.py"]\n'
+        )
+        Path("main.py").touch()
+        project_root = Path.cwd()
+
+        result = runner.invoke(cli, ["check", "."])
+
+    assert result.exit_code == 0
+    pyrefly_calls = [
+        invocation
+        for invocation in mock_run.call_args_list
+        if invocation.args[0][0] == "pyrefly"
+    ]
+    assert len(pyrefly_calls) == 1
+    assert pyrefly_calls[0].args[0] == ["pyrefly", "check"]
+    assert pyrefly_calls[0].kwargs["cwd"] == project_root
+
+
 def test_has_project_config(tmp_path: Path) -> None:
     """Tests project config detection via dedicated files and pyproject.
 
@@ -505,15 +536,124 @@ 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_pyrefly_uses_project_mode_only_for_configured_directories(
+    tmp_path: Path,
+) -> None:
+    """Directories use config discovery while explicit files stay explicit."""
+    (tmp_path / "pyrefly.toml").write_text(
+        'project-excludes = ["**/excluded.py"]\n'
+    )
+    py_file = tmp_path / "main.py"
+    py_file.touch()
+
+    with patch("shutil.which", side_effect=lambda name: name):
+        directory_tools = {
+            tool["name"]: tool
+            for tool in _get_tool_definitions(tmp_path, tmp_path)
+        }
+        file_tools = {
+            tool["name"]: tool
+            for tool in _get_tool_definitions(py_file, tmp_path)
+        }
+
+    assert directory_tools["pyrefly"]["check"] == ["pyrefly", "check"]
+    assert directory_tools["pyrefly"]["cwd"] == tmp_path
+    assert file_tools["pyrefly"]["check"] == [
+        "pyrefly",
+        "check",
+        str(py_file),
+    ]
+    assert "cwd" not in file_tools["pyrefly"]
+
+
+def test_pyrefly_bundled_config_keeps_an_explicit_directory(
+    tmp_path: Path,
+) -> None:
+    """Project mode cannot use a config rooted in the installed package."""
+    (tmp_path / "main.py").touch()
+
+    with patch("shutil.which", side_effect=lambda name: name):
+        tools = {
+            tool["name"]: tool
+            for tool in _get_tool_definitions(tmp_path, tmp_path)
+        }
+
+    assert tools["pyrefly"]["check"] == [
+        "pyrefly",
+        "check",
+        "--config",
+        str(_bundled_config("pyrefly")),
+        str(tmp_path),
+    ]
+    assert "cwd" not in tools["pyrefly"]
+
+
+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()
 
-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
+    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
@@ -560,6 +700,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,
@@ -1789,10 +1952,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="")
 
@@ -1803,13 +1966,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.2 → readability_cli-0.8.4}/uv.lock

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