py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/format/format_progress.py

@@ -0,0 +1,62 @@
+"""Format progress module."""
+
+from pathlib import Path
+
+from tqdm import tqdm
+
+
+class FormatProgress:
+    """Progress manager for format operations."""
+
+    def truncate_filename(self, filename: str) -> str:
+        """Truncate filename to fit in progress bar."""
+        max_len = 28
+        if len(filename) > max_len:
+            return filename[: max_len - 3] + "..."
+        return filename
+
+    def create_progress_bar(self, total_files: int) -> tqdm:
+        """Create a progress bar for file processing."""
+        return tqdm(
+            total=total_files,
+            unit="file",
+            leave=False,
+            dynamic_ncols=True,
+            bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]",
+        )
+
+    def update_progress_bar(
+        self,
+        pbar: tqdm,
+        truncated_name: str,
+        status: str,
+    ) -> None:
+        """Update progress bar with current status."""
+        pbar.set_description(f"Processing {truncated_name:<28} [{status}]")
+        pbar.update(1)
+
+    def close_progress_bar(self, pbar: tqdm, total_files: int) -> None:
+        """Close the progress bar and ensure it shows 100%."""
+        try:
+            # Ensure progress bar shows 100% before closing
+            if total_files > 0:
+                pbar.n = total_files
+                pbar.refresh()
+        finally:
+            # Always close the progress bar
+            pbar.disable = True
+            pbar.close()
+
+    def print_format_error(self, file_path: Path, error_message: str) -> None:
+        """Print format error message."""
+        print()
+        print(f"Formatting failed for file: {file_path}")
+        # Print the specific error message if available
+        if error_message:
+            print(f"Error details: {error_message}")
+        print("Stopping at first error as requested.")
+
+    def print_processing_error(self, file_path: Path, error: Exception) -> None:
+        """Print processing error message."""
+        print()
+        print(f"Error processing {file_path}: {error}")

wl_cli/commands/format/format_reporter.py

@@ -0,0 +1,31 @@
+"""Format reporter module."""
+
+from pathlib import Path
+
+
+class FormatReporter:
+    """Reporter for format command."""
+
+    def generate_format_report(self, quiet, unsafe, paths, env):
+        """Generate format report."""
+        # Create todos directory if it doesn't exist
+        todos_dir = Path("todos")
+        todos_dir.mkdir(exist_ok=True)
+
+        # Generate report content
+        report_lines = []
+        report_lines.append("# Format Report\n")
+        report_lines.append("## Configuration\n")
+        report_lines.append(f"- Quiet mode: {quiet}\n")
+        report_lines.append(f"- Unsafe fixes: {unsafe}\n")
+        report_lines.append(
+            f"- Custom paths: {paths if paths else 'None (using defaults)'}\n"
+        )
+
+        # Save report
+        report_path = todos_dir / "format_report.md"
+        with open(report_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(report_lines))
+
+        if not quiet:
+            print(f"Format report generated at {report_path}")

wl_cli/commands/format/python_formatter.py

@@ -0,0 +1,506 @@
+"""
+Python code formatting utilities for WL Commands."""
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from ...utils.subprocess_utils import SubprocessExecutor, SubprocessResult
+from ...utils.uv_run import run_uv_command
+from .format_outcome import FormatFailure
+
+
+@dataclass(frozen=True)
+class FormatCommandResult:
+    """Small result value for one formatter command (#164).
+
+    Carrying ``returncode`` and ``launch_error`` -- rather than a bool -- is
+    what lets the caller tell "ruff judged the file bad" from "ruff never ran"
+    without re-sniffing output text.
+
+    ``launcher_failure`` carries the one case those two fields cannot express
+    (#200): ``uv run ruff ...`` exiting non-zero because **uv** failed -- an
+    unsatisfiable dependency, an offline cache miss, a malformed ``uv.lock``
+    -- with ruff never started. Those exit codes are otherwise the same ones
+    ruff uses for its own verdicts (``1`` for "violations remain", ``2`` for a
+    file or config it refuses), so the streams are what tell them apart (see
+    :func:`_launcher_failure` and :func:`_confirm_launcher_failure`), never a
+    substring of the text.
+    """
+
+    ok: bool
+    output: str
+    returncode: int | None
+    launch_error: str | None
+    #: The launcher's own diagnostic when ``uv`` failed before its child could
+    #: produce a verdict; ``None`` when the child (whatever it said) ran.
+    launcher_failure: str | None = None
+
+    @property
+    def tool_missing(self) -> bool:
+        """True when the formatter never got to run (not a format verdict)."""
+        return self.launch_error is not None or self.returncode == 127
+
+
+def _launcher_failure(stdout: str, stderr: str, returncode: int | None) -> str | None:
+    """``uv``'s own failure text, or ``None`` when the child produced a verdict.
+
+    #200: both ``uv`` failing and ``ruff check`` finding unfixable violations
+    exit ``1``. The streams separate them without sniffing either program's
+    wording:
+
+    * ruff prints **every** diagnostic to stdout, and its rc1 summary
+      (``Found N errors.``) there too, so a real verdict always leaves text on
+      stdout;
+    * uv reports its own failures on stderr and writes nothing to stdout.
+
+    A non-zero exit with an empty stdout and a non-empty stderr is therefore a
+    *candidate* launcher failure, and that stderr text is its reason.
+
+    rc ``>= 2`` cannot be settled here. ``uv`` exits ``2`` when it cannot start
+    the command at all (a malformed ``uv.lock``, an unrecognised flag), but
+    real ruff *also* exits ``2`` with an empty stdout and its own text on
+    stderr when it refuses a file (``error: Failed to parse ...``) or its
+    config (``ruff failed / Cause: Unknown rule selector``) -- measured
+    against real ruff, not assumed. :func:`_confirm_launcher_failure` settles
+    that case with a differential probe; this function only answers "could
+    have been the launcher".
+
+    Trade-off for rc1, deliberately fail-*open*: an rc1 that is silent on both
+    streams stays a ruff verdict. There is no evidence a launcher failed, and
+    guessing "formatter failure" there would abort ``wl lint``'s prefix --
+    skipping its own ruff run, mypy and the report, the regression #188 fixed.
+    If uv did fail silently, lint's own independent ruff run still reports the
+    breakage.
+    """
+    if returncode is None or returncode < 1:
+        return None
+    if stdout.strip() or not stderr.strip():
+        return None
+    return stderr.strip()
+
+
+def _confirm_launcher_failure(
+    executor: SubprocessExecutor,
+    command: list,
+    env: dict,
+    result: SubprocessResult,
+    candidate: str,
+) -> str | None:
+    """Decide whether an ambiguous rc2 failure was uv's, not the child's.
+
+    Since ruff's own refusals share uv's rc2 shape (empty stdout, text on
+    stderr), the streams cannot separate "ruff refused this file/config" from
+    "ruff never started". The discriminator that does not read either
+    program's wording is differential: re-run the same child without the
+    ``uv run`` prefix. A child that produces a *different* outcome when run
+    directly never got that far through uv, so the launcher failed; the same
+    shape of failure -- the same exit code, nothing on stdout -- is the
+    child's own diagnostic.
+
+    #215: "same shape" deliberately excludes the stderr *text*. The direct
+    re-run resolves a different ``ruff`` than ``uv run`` does -- the one on
+    ``PATH``, which may be any release. Two ruff versions word the same refusal
+    (``--select INVALID``, a file it cannot parse) differently, so requiring
+    the texts to match promoted a genuine rc2 verdict to a launcher failure
+    whenever the developer's ``ruff`` drifted from the project's pin. Exit code
+    plus an empty stdout is what identifies the verdict; the wording belongs to
+    whichever release produced it.
+
+    A uv-managed ``ruff`` is usually *not* on PATH, so the direct re-run can
+    itself be unlaunchable. Then the question is turned around and asked of
+    the launcher: ``uv run ruff --version`` succeeds when uv can still start
+    ruff, which makes the rc2 ruff's own; if even that fails, the tool could
+    not be started in this environment and the launcher reading stands.
+
+    Only the ambiguous shape reaches here -- a run that left text on stdout is
+    a verdict, and rc0/rc1 are settled by :func:`_launcher_failure` -- and
+    every probe is captured (``quiet=True``), so nothing prints twice.
+    ``ruff check --fix`` and ``ruff format`` are idempotent, so re-running them
+    changes nothing the first run did not already change.
+
+    Returns *candidate* (the stderr text) when the launcher is at fault, and
+    ``None`` when the direct run fails the same way -- i.e. the diagnostic
+    belongs to the child.
+    """
+    if len(command) < 3 or command[0] != "uv" or command[1] != "run":
+        # Not a uv-launched command: no launcher to blame.
+        return candidate
+    try:
+        probe = executor.run(command[2:], env=env, quiet=True)
+    except Exception:
+        probe = None
+    if probe is None or probe.launch_error is not None or probe.returncode == 127:
+        # The child is not directly runnable (usually: uv-managed, not on
+        # PATH). Ask uv whether it can start the tool at all.
+        return None if _launcher_can_start_child(executor, command, env) else candidate
+    # Same exit code with nothing on stdout is the child's verdict shape, no
+    # matter which ruff release produced the stderr wording (#215).
+    child_reached_the_same_verdict = (
+        probe.returncode == result.returncode and not (probe.stdout or "").strip()
+    )
+    return None if child_reached_the_same_verdict else candidate
+
+
+def _launcher_can_start_child(
+    executor: SubprocessExecutor, command: list, env: dict
+) -> bool:
+    """Whether the launcher can start its child at all, asked cheaply.
+
+    ``command`` is ``["uv", "run", "<tool>", ...]``; the probe keeps the
+    launcher prefix and the tool, and replaces the arguments with
+    ``--version`` -- a side-effect-free run that succeeds only if uv can still
+    get as far as executing the tool.
+    """
+    try:
+        probe = executor.run(
+            [*command[:2], command[2], "--version"], env=env, quiet=True
+        )
+    except Exception:
+        return False
+    return probe.launch_error is None and probe.returncode == 0
+
+
+def _run_format_command(
+    command: list, env: dict, quiet: bool, passthrough: bool = False
+) -> FormatCommandResult:
+    """Run a formatting command and report what it actually did (#164)."""
+    # Use SubprocessExecutor for consistent command execution
+    executor = SubprocessExecutor()
+
+    # ``run_uv_command`` owns the "uv is not installed" retry, shared with the
+    # pre-commit run (#165); the executor stays here so a caller keeps one
+    # patch point for the command it starts.
+    final_result = run_uv_command(executor, command, env=env, quiet=not passthrough)
+    stdout = final_result.stdout or ""
+    stderr = final_result.stderr or ""
+    output = stdout + "\n" + stderr if stderr else stdout
+
+    # Handle command failure - only log the error, don't raise exception.
+    # ``passthrough`` runs already wrote their own output, so only the exit
+    # code is ours to add there; a captured run is echoed instead (#200
+    # MEDIUM-1), otherwise the diagnostics the verdict was built from would
+    # never reach a non-quiet user.
+    if not quiet:
+        if passthrough and final_result.returncode != 0:
+            error_msg = f"Command failed with return code {final_result.returncode}"
+            if stderr:
+                error_msg += f": {stderr.strip()}"
+            print(f"Warning: {error_msg}")
+        elif not passthrough and output.strip():
+            print(output.strip())
+
+    launcher_failure = _launcher_failure(stdout, stderr, final_result.returncode)
+    if launcher_failure is not None and final_result.returncode == 2:
+        # rc2 is shared by uv's own startup failures and ruff's own refusals;
+        # only a direct re-run of the same child can tell them apart (NIT-1).
+        launcher_failure = _confirm_launcher_failure(
+            executor, command, env, final_result, launcher_failure
+        )
+
+    return FormatCommandResult(
+        ok=final_result.returncode == 0,
+        output=output,
+        returncode=final_result.returncode,
+        launch_error=final_result.launch_error,
+        launcher_failure=launcher_failure,
+    )
+
+
+@dataclass(frozen=True)
+class RuffCheckVerdict(FormatFailure):
+    """A ``ruff check --fix`` verdict, not a formatter failure (#188).
+
+    ``ruff check`` exits ``1`` when its own run leaves something to report --
+    after every fix it could apply. That is a *lint* finding: ``wl lint``
+    re-runs ruff itself and owns the verdict, so the exit ``1`` must not abort
+    its format prefix. It stays a failure for ``wl format``, which promises the
+    check step came back clean, and it keeps ``kind == "ruff"`` so every
+    existing ``FormatOutcome`` reader still sees a formatter-shaped failure.
+
+    It is a subclass rather than a fourth ``kind`` because the closed
+    vocabulary lives in ``format_outcome.py``, which this ticket does not own.
+
+    What actually lands here (#200). The check step's rc1 is *not* limited to
+    ``F821``-style unfixable violations: ruff also reports a file it cannot
+    parse as ``invalid-syntax`` diagnostics on stdout and exits ``1``, so the
+    check step's own verdict is this one. Since
+    :meth:`FormatExecutor.format_python_file` returns at the failed check step,
+    ``ruff format`` never runs for that file and the syntax error is carried
+    *only* as this verdict -- so ``wl lint`` does **not** stop before its own
+    ruff run; lint's run reports the ``invalid-syntax`` finding and the run
+    stays red.
+
+    A plain :class:`FormatFailure` instead means the check step's own verdict
+    was unavailable: ``uv`` failed to start ruff (:attr:`FormatCommandResult.launcher_failure`,
+    #200), the launcher is missing, or ruff exited ``>= 2`` because it refused
+    the config/arguments. For a *directory* run :func:`format_with_ruff` also
+    runs ``ruff format``, whose parse failure is rc2 (``error: Failed to parse
+    ...``) and is that plain failure -- which is why a syntax error stops
+    ``wl lint`` there, but not on the single-file path above.
+    """
+
+
+def _ruff_failure(
+    directory: str, result: FormatCommandResult, step: str
+) -> FormatFailure:
+    """Turn a failed formatter command into the failure vocabulary (#164)."""
+    if result.tool_missing or result.launcher_failure is not None:
+        # #200 NIT-2: name the actual startup failure. ``tool_missing`` is the
+        # closed vocabulary's only "never ran" slot, but saying "ruff could not
+        # be launched" for a uv failure reads as "install ruff"; a uv launcher
+        # failure gets its own wording, and a missing executable keeps the
+        # launch error it actually raised (F6: no over-attribution).
+        if result.launcher_failure is not None:
+            message = (
+                f"the uv launcher failed before ruff ran ({step}): "
+                f"{result.launcher_failure}"
+            )
+        else:
+            reason = result.launch_error or f"exit code {result.returncode}"
+            message = f"ruff could not be started ({step}): {reason}"
+        return FormatFailure(
+            path=Path(directory),
+            kind="tool_missing",
+            message=message,
+        )
+    message = result.output.strip() or (
+        f"{step} failed with return code {result.returncode}"
+    )
+    return FormatFailure(path=Path(directory), kind="ruff", message=message)
+
+
+def _ruff_check_failure(directory: str, result: FormatCommandResult) -> FormatFailure:
+    """Classify a failed ``ruff check`` run (#188, #200).
+
+    Exit ``1`` from a ruff that *did* run is "violations remain" -- a lint
+    verdict, carried as :class:`RuffCheckVerdict`. Anything else is a
+    formatter failure the lint prefix must still stop on: a launcher that
+    never ran, ``uv`` itself failing with rc1 (``launcher_failure``, #200 --
+    indistinguishable from a verdict by exit code alone), or exit ``>= 2``
+    (ruff refused the config/arguments).
+    """
+    if (
+        not result.tool_missing
+        and result.launcher_failure is None
+        and result.returncode == 1
+    ):
+        message = result.output.strip() or "ruff check left unfixed violations"
+        return RuffCheckVerdict(path=Path(directory), kind="ruff", message=message)
+    return _ruff_failure(directory, result, "ruff check")
+
+
+def format_with_ruff(
+    directory: str, env: dict, quiet: bool = False, unsafe: bool = False
+) -> tuple[FormatFailure, ...]:
+    """Format directory with ruff only; returns every command that failed."""
+    failures: list[FormatFailure] = []
+    try:
+        # Run ruff check with fix
+        ruff_check_cmd = ["uv", "run", "ruff", "check", "--fix"]
+        if unsafe:
+            ruff_check_cmd.append("--unsafe-fixes")
+        ruff_check_cmd.append(directory)
+
+        # #200 MEDIUM-1: both steps are captured even when not quiet. The
+        # passthrough run left stdout/stderr empty, so a launcher failure was
+        # indistinguishable from a verdict and ``wl lint`` / ``wl format <dir>``
+        # treated a ruff that never ran as a lint verdict. ``_run_format_command``
+        # echoes the captured text when not quiet.
+        check_result = _run_format_command(
+            ruff_check_cmd, env, quiet, passthrough=False
+        )
+        if not check_result.ok:
+            # #188: rc1 is "violations remain", which the lint prefix must not
+            # mistake for a formatter that could not run.
+            failures.append(_ruff_check_failure(directory, check_result))
+
+        # Run ruff format for code formatting
+        format_result = _run_format_command(
+            [
+                "uv",
+                "run",
+                "ruff",
+                "format",
+                directory,
+            ],
+            env,
+            quiet,
+            passthrough=False,
+        )
+        if not format_result.ok:
+            failures.append(_ruff_failure(directory, format_result, "ruff format"))
+
+        # Note: We no longer manually handle trailing whitespace and end-of-file newlines here
+        # because pre-commit's trailing-whitespace and end-of-file-fixer hooks should handle this
+        # This ensures consistency between wl format and running pre-commit directly
+    except subprocess.CalledProcessError as e:
+        if not quiet:
+            print(f"Warning: ruff formatting failed with return code {e.returncode}")
+        raise
+    except FileNotFoundError as e:
+        if not quiet:
+            print(f"Warning: uv or ruff not found in PATH: {e}")
+        failures.append(
+            FormatFailure(
+                path=Path(directory),
+                kind="tool_missing",
+                message=f"uv or ruff not found in PATH: {e}",
+            )
+        )
+    except Exception as e:
+        if not quiet:
+            print(f"Warning occurred during ruff formatting: {e}")
+        failures.append(
+            FormatFailure(
+                path=Path(directory),
+                kind="ruff",
+                message=f"Warning occurred during ruff formatting: {e}",
+            )
+        )
+    return tuple(failures)
+
+
+def format_with_python_tools(
+    directory: str, env: dict, quiet: bool = False, unsafe: bool = False
+) -> tuple[FormatFailure, ...]:
+    """Format directory with Python tools (ruff only)."""
+    try:
+        # Format with ruff only
+        return format_with_ruff(directory, env, quiet, unsafe)
+    except subprocess.CalledProcessError as e:
+        if not quiet:
+            print(f"Warning: Python formatting failed with return code {e.returncode}")
+        raise
+    except Exception as e:
+        if not quiet:
+            print(f"Warning occurred during Python formatting: {e}")
+        return (
+            FormatFailure(
+                path=Path(directory),
+                kind="ruff",
+                message=f"Warning occurred during Python formatting: {e}",
+            ),
+        )
+
+
+def format_tools_scripts(
+    tools_dir: str, env: dict, quiet: bool, unsafe: bool = False
+) -> None:
+    """Format Python files in tools directory with ruff."""
+    tools_path = Path(tools_dir)
+    if not tools_path.exists():
+        if not quiet:
+            print(f"Tools directory {tools_dir} does not exist, skipping...")
+        return
+
+    # Find all Python files in tools directory
+    python_files = list(tools_path.glob("**/*.py"))
+    if python_files:
+        # Fix issues in tools Python files with ruff check
+        try:
+            ruff_check_cmd = ["uv", "run", "ruff", "check", "--fix"]
+            if unsafe:
+                ruff_check_cmd.append("--unsafe-fixes")
+            ruff_check_cmd.extend([str(f) for f in python_files])
+
+            _run_format_command(ruff_check_cmd, env, quiet, passthrough=not quiet)
+        except Exception as e:
+            if not quiet:
+                print(f"Warning: ruff check failed for tools scripts: {e}")
+
+        # Format tools Python files with ruff format
+        try:
+            _run_format_command(
+                ["uv", "run", "ruff", "format"] + [str(f) for f in python_files],
+                env,
+                quiet,
+                passthrough=not quiet,
+            )
+        except Exception as e:
+            if not quiet:
+                print(f"Warning: ruff format failed for tools scripts: {e}")
+    else:
+        if not quiet:
+            print("No Python files found in tools directory")
+
+
+def format_examples(
+    examples_dir: str, env: dict, quiet: bool, unsafe: bool = False
+) -> None:
+    """Format examples directory with ruff."""
+    examples_path = Path(examples_dir)
+    if not examples_path.exists():
+        if not quiet:
+            print(f"Examples directory {examples_dir} does not exist, skipping...")
+        return
+
+    # Fix issues in examples with ruff check
+    try:
+        ruff_check_cmd = ["uv", "run", "ruff", "check", "--fix"]
+        if unsafe:
+            ruff_check_cmd.append("--unsafe-fixes")
+        ruff_check_cmd.append(examples_dir)
+
+        _run_format_command(ruff_check_cmd, env, quiet, passthrough=not quiet)
+    except Exception as e:
+        if not quiet:
+            print(f"Warning: ruff check failed for examples: {e}")
+
+    # Format examples with ruff format
+    try:
+        _run_format_command(
+            ["uv", "run", "ruff", "format", examples_dir],
+            env,
+            quiet,
+            passthrough=not quiet,
+        )
+    except Exception as e:
+        if not quiet:
+            print(f"Warning: ruff format failed for examples: {e}")
+
+
+def generate_type_stubs(src_dir: str, typings_dir: str, env: dict, quiet: bool) -> None:
+    """Generate type stubs."""
+    if not quiet:
+        print(f"Generating type stubs for {src_dir}...")
+
+    # Check if src_dir exists
+    src_path = Path(src_dir)
+    if not src_path.exists():
+        if not quiet:
+            print(f"Target {src_dir} does not exist, skipping...")
+        return
+
+    # Ensure typings directory exists
+    typings_path = Path(typings_dir)
+    typings_path.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Use uv run --with mypy python -c to call mypy.stubgen
+        # Use repr() to properly escape paths for the Python command
+        cmd = [
+            "uv",
+            "run",
+            "--with",
+            "mypy",
+            "python",
+            "-c",
+            f"from mypy.stubgen import main; main([{repr(src_dir)}, '-o', {repr(typings_dir)}])",
+        ]
+
+        _run_format_command(cmd, env, quiet, passthrough=False)
+    except Exception as e:
+        if not quiet:
+            print(f"Warning: Error generating type stubs: {e}")
+
+
+__all__ = [
+    "RuffCheckVerdict",
+    "_run_format_command",
+    "format_with_ruff",
+    "format_with_python_tools",
+    "format_tools_scripts",
+    "format_examples",
+    "generate_type_stubs",
+]