py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/clean/core.py

@@ -0,0 +1,236 @@
+"""
+Core cleaning utilities for clean command.
+"""
+
+import concurrent.futures
+import glob
+import os
+import shutil
+from collections.abc import Callable
+from typing import Any
+
+from wl_cli.utils.logging import log_info_pair
+
+
+def remove_directories(dirs_to_remove: list[str], dry_run: bool = False) -> None:
+    """Remove specific directories."""
+    for dir_name in dirs_to_remove:
+        if os.path.exists(dir_name):
+            try:
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove directory: {dir_name}", f"将删除目录: {dir_name}"
+                    )
+                else:
+                    shutil.rmtree(dir_name)
+                    log_info_pair(
+                        f"Removed directory: {dir_name}", f"已删除目录: {dir_name}"
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"Failed to remove directory {dir_name}: {e}",
+                    f"删除目录 {dir_name} 失败: {e}",
+                )
+
+
+def remove_files(files_to_remove: list[str], dry_run: bool = False) -> None:
+    """Remove specific files, supporting wildcard patterns."""
+    for pattern in files_to_remove:
+        # Handle wildcard patterns
+        if any(char in pattern for char in "*?[]"):
+            matched_files = glob.glob(pattern, recursive=True)
+            for file_name in matched_files:
+                if os.path.isfile(file_name):
+                    try:
+                        if dry_run:
+                            log_info_pair(
+                                f"Would remove file: {file_name}",
+                                f"将删除文件: {file_name}",
+                            )
+                        else:
+                            os.remove(file_name)
+                            log_info_pair(
+                                f"Removed file: {file_name}", f"已删除文件: {file_name}"
+                            )
+                    except Exception as e:
+                        log_info_pair(
+                            f"Failed to remove file {file_name}: {e}",
+                            f"删除文件 {file_name} 失败: {e}",
+                        )
+        else:
+            # Handle exact file paths
+            if os.path.exists(pattern) and os.path.isfile(pattern):
+                try:
+                    if dry_run:
+                        log_info_pair(
+                            f"Would remove file: {pattern}", f"将删除文件: {pattern}"
+                        )
+                    else:
+                        os.remove(pattern)
+                        log_info_pair(
+                            f"Removed file: {pattern}", f"已删除文件: {pattern}"
+                        )
+                except Exception as e:
+                    log_info_pair(
+                        f"Failed to remove file {pattern}: {e}",
+                        f"删除文件 {pattern} 失败: {e}",
+                    )
+
+
+def _execute_cleaning_task(task: tuple[Callable, dict]) -> tuple[str, bool, Any]:
+    """
+    Execute a cleaning task with error handling
+    执行清理任务并处理错误
+    """
+    task_func, task_args = task
+    task_name = task_func.__name__
+
+    # Get human-readable task name
+    task_display_names = {
+        "clean_build_artifacts": "Build artifacts",
+        "clean_lfs_artifacts": "Git LFS artifacts",
+        "clean_rust_artifacts": "Rust artifacts",
+        "remove_virtual_environments": "Virtual environments",
+        "remove_auto_activation_scripts": "Auto-activation scripts",
+        "remove_rust_analyzer_dirs": "Rust analyzer directories",
+        "remove_uv_lock": "UV lock file",
+    }
+    display_name = task_display_names.get(task_name, task_name)
+
+    try:
+        log_info_pair(
+            f"\n=== Starting: {display_name} ===", f"\n=== 开始: {display_name} ==="
+        )
+
+        task_func(**task_args)
+
+        log_info_pair(
+            f"=== Completed: {display_name} ===", f"=== 完成: {display_name} ==="
+        )
+        return task_name, True, None
+    except Exception as e:
+        log_info_pair(
+            f"=== Failed: {display_name} ===", f"=== 失败: {display_name} ==="
+        )
+        log_info_pair(f"Error: {e}", f"错误: {e}")
+        return task_name, False, e
+
+
+def clean_all_artifacts(
+    dry_run: bool = False, config: str | None = None, parallel: bool = False
+) -> None:
+    """
+    Clean all artifacts including virtual environment
+    清理所有产物，包括虚拟环境
+    """
+    log_info_pair("Cleaning all artifacts...", "正在清理所有产物...")
+
+    # Log dry run mode
+    if dry_run:
+        log_info_pair(
+            "Dry run mode: No files will be deleted.", "Dry run模式：不会删除任何文件。"
+        )
+
+    # Log parallel mode
+    if parallel:
+        log_info_pair("Parallel execution enabled.", "已启用并行执行。")
+
+    # Prepare cleaning tasks
+    tasks: list[tuple[Callable, dict]] = []
+
+    # Lazy imports to avoid circular imports (build.py imports from core.py)
+    from wl_cli.commands.clean.build import clean_build_artifacts
+    from wl_cli.commands.clean.lfs import clean_lfs_artifacts
+    from wl_cli.commands.clean.rust import (
+        clean_rust_artifacts as _clean_rust_artifacts,
+    )
+    from wl_cli.commands.clean.rust import (
+        remove_rust_analyzer_dirs,
+    )
+    from wl_cli.commands.clean.venv import (
+        remove_auto_activation_scripts,
+        remove_uv_lock,
+        remove_virtual_environments,
+    )
+
+    # Add build artifacts cleaning
+    tasks.append((clean_build_artifacts, {"dry_run": dry_run, "config": config}))
+
+    # Add LFS cleaning
+    tasks.append((clean_lfs_artifacts, {"dry_run": dry_run}))
+
+    # Add Rust artifacts cleaning
+    tasks.append((_clean_rust_artifacts, {"dry_run": dry_run}))
+
+    # Add virtual environment cleaning
+    tasks.append((remove_virtual_environments, {"dry_run": dry_run}))
+
+    # Add auto-activation scripts removal
+    tasks.append((remove_auto_activation_scripts, {"dry_run": dry_run}))
+
+    # Add rust-analyzer directories removal
+    tasks.append((remove_rust_analyzer_dirs, {"dry_run": dry_run}))
+
+    # Add uv.lock file removal
+    tasks.append((remove_uv_lock, {"dry_run": dry_run}))
+
+    # Execute tasks
+    success_count = 0
+    failure_count = 0
+    total_tasks = len(tasks)
+    completed_tasks = 0
+
+    log_info_pair(
+        f"Starting {total_tasks} cleaning tasks...",
+        f"开始执行 {total_tasks} 个清理任务...",
+    )
+
+    if parallel:
+        # Parallel execution
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+            # Submit all tasks
+            future_to_task = {
+                executor.submit(_execute_cleaning_task, task): task for task in tasks
+            }
+
+            # Process results as they complete
+            for future in concurrent.futures.as_completed(future_to_task):
+                task_name, success, error = future.result()
+                completed_tasks += 1
+
+                if success:
+                    success_count += 1
+                else:
+                    failure_count += 1
+
+                # Show progress
+                progress_percent = (completed_tasks / total_tasks) * 100
+                log_info_pair(
+                    f"Progress: {completed_tasks}/{total_tasks} ({progress_percent:.1f}%)",
+                    f"进度: {completed_tasks}/{total_tasks} ({progress_percent:.1f}%)",
+                )
+    else:
+        # Sequential execution (default)
+        for task in tasks:
+            task_name, success, error = _execute_cleaning_task(task)
+            completed_tasks += 1
+
+            if success:
+                success_count += 1
+            else:
+                failure_count += 1
+
+            # Show progress
+            progress_percent = (completed_tasks / total_tasks) * 100
+            log_info_pair(
+                f"Progress: {completed_tasks}/{total_tasks} ({progress_percent:.1f}%)",
+                f"进度: {completed_tasks}/{total_tasks} ({progress_percent:.1f}%)",
+            )
+
+    # Log summary
+    log_info_pair(
+        f"Cleaning operations completed: {success_count} succeeded, {failure_count} failed",
+        f"清理操作完成: {success_count} 成功, {failure_count} 失败",
+    )
+
+    log_info_pair("All artifacts cleaning completed.", "所有产物清理完成。")

wl_cli/commands/clean/dead_code/dead_code_command.py

@@ -0,0 +1,70 @@
+"""Dead code command module.
+Main entry point for the dead code cleanup functionality.
+"""
+
+from ....utils.root import RootKind
+from ....utils.root_fallback import current_root
+from .detector import DeadCodeDetector
+from .fixer import DeadCodeFixer
+from .reporter import DeadCodeReporter, TestSuggestion
+
+
+class DeadCodeCommand:
+    """Command for dead code cleanup."""
+
+    def __init__(self) -> None:
+        """Initialize the dead code command."""
+        self.detector = DeadCodeDetector()
+        self.fixer = DeadCodeFixer()
+
+    def run(self, dry_run: bool = False, json: bool = False) -> int:
+        """Run the dead code cleanup command.
+
+        Args:
+            dry_run: Whether to only scan without fixing.
+            json: Whether to output JSON format.
+
+        Returns:
+            Exit code (0 for success, 1 for error).
+        """
+        # The reporter emits through ``log_*_pair``, which picks the language
+        # itself (#167), so no language is threaded through here.
+        reporter = DeadCodeReporter()
+
+        try:
+            # Find project root: single-root consumer (#160), taken as a bare
+            # Path because that is this command's contract.
+            project_root = current_root(RootKind.PROJECT).path
+
+            # Step 1: Detect dead code
+            issues = self.detector.detect(project_root)
+            test_suggestions: list[TestSuggestion] = []
+
+            # Step 2: Fix issues
+            if not dry_run:
+                issues = self.fixer.fix(issues, project_root, dry_run=False)
+
+            # Step 3: Report
+            if json:
+                json_output = reporter.report_json(issues, test_suggestions)
+                print(json_output)
+            else:
+                reporter.report_cli(issues, test_suggestions, dry_run=dry_run)
+
+            return 0
+
+        except Exception as e:
+            from ....utils.logging import log_error_pair
+
+            if json:
+                # For JSON output, print error in JSON format without banners
+                import json as json_module
+
+                error_output = {"error": str(e), "error_zh": "运行死代码清理时出错"}
+                print(json_module.dumps(error_output, ensure_ascii=False))
+            else:
+                log_error_pair(
+                    f"Error running dead code cleanup: {e}",
+                    f"运行死代码清理时出错: {e}",
+                )
+            return 1

wl_cli/commands/clean/dead_code/detector.py

@@ -0,0 +1,161 @@
+"""
+Dead code detector module.
+Handles detection of dead code using Ruff.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ....utils.logging import log_error_pair
+from ....utils.subprocess_utils import SubprocessExecutor, SubprocessResult
+from .reporter import DeadCodeIssue
+
+
+class DeadCodeDetector:
+    """Detector for dead code issues."""
+
+    def __init__(self) -> None:
+        """Initialize the dead code detector."""
+        self.executor = SubprocessExecutor()
+
+    def detect(self, project_root: Path) -> list[DeadCodeIssue]:
+        """
+        Detect dead code issues.
+
+        Args:
+            project_root: Root directory of the project.
+
+        Returns:
+            List of DeadCodeIssue objects.
+        """
+        issues: list[DeadCodeIssue] = []
+
+        # Run Ruff detection
+        ruff_issues = self._detect_with_ruff(project_root)
+        issues.extend(ruff_issues)
+
+        return issues
+
+    def _detect_with_ruff(self, project_root: Path) -> list[DeadCodeIssue]:
+        """
+        Detect dead code using Ruff.
+
+        Args:
+            project_root: Root directory of the project.
+
+        Returns:
+            List of DeadCodeIssue objects from Ruff.
+        """
+        issues: list[DeadCodeIssue] = []
+
+        # Prepare Ruff command
+        cmd = [
+            "ruff",
+            "check",
+            "--select",
+            "F401,F841",
+            "--output-format",
+            "json",
+            ".",
+        ]
+
+        # Run Ruff command
+        result = self.executor.run(command=cmd, cwd=project_root, quiet=True)
+
+        # Only a Ruff that never ran has nothing to say. Every other non-zero
+        # exit still carries a report: Ruff exits 1 exactly when it *found*
+        # violations, which is the case this detector exists for (#150).
+        if self._ruff_unavailable(result):
+            log_error_pair(
+                "Ruff is not installed. Please install Ruff to use dead code detection.",
+                "Ruff 未安装。请安装 Ruff 以使用死代码检测功能。",
+            )
+            return issues
+
+        # Parse Ruff output
+        if result.stdout:
+            try:
+                ruff_output = json.loads(result.stdout)
+                issues = self._parse_ruff_output(ruff_output)
+            except json.JSONDecodeError:
+                # If JSON parsing fails, return empty list
+                pass
+
+        return issues
+
+    @staticmethod
+    def _ruff_unavailable(result: SubprocessResult) -> bool:
+        """Whether the ``ruff`` process never got as far as reporting.
+
+        Deliberately **not** ``returncode != 0``: Ruff exits 1 whenever it has
+        violations, so that test silently discarded every finding (#150). The
+        discriminator is :attr:`SubprocessResult.launch_error`, the field set
+        only on the ``except`` arm of
+        :meth:`SubprocessExecutor._execute_command` -- i.e. when the
+        executable could not be started at all (#100/#101). ``127`` is kept as
+        a belt-and-braces spelling of a shell's "command not found", which
+        Ruff itself never returns.
+
+        The former ``"not found" in stderr`` sniff is gone with it: a substring
+        of a child's *stderr* cannot distinguish "no such tool" from a Ruff
+        that ran, reported something and exited 1.
+
+        Args:
+            result: The finished Ruff subprocess result.
+
+        Returns:
+            True when Ruff never produced a report.
+        """
+        if result.launch_error is not None:
+            return True
+        return result.returncode == 127
+
+    def _parse_ruff_output(
+        self, ruff_output: list[dict[str, Any]]
+    ) -> list[DeadCodeIssue]:
+        """
+        Parse Ruff JSON output into DeadCodeIssue objects.
+
+        Args:
+            ruff_output: Ruff JSON output as a list of dictionaries.
+
+        Returns:
+            List of DeadCodeIssue objects.
+        """
+        issues: list[DeadCodeIssue] = []
+
+        for item in ruff_output:
+            code = item.get("code", "")
+            filename = item.get("filename", "")
+            line = item.get("location", {}).get("row", None)
+            message = item.get("message", "")
+
+            if code == "F401":
+                # Unused import
+                # Extract import name from message like "`os` imported but unused"
+                name = message.split("`")[1] if "`" in message else None
+                issue = DeadCodeIssue(
+                    type="unused_import",
+                    file=filename,
+                    line=line,
+                    name=name,
+                    severity="safe",
+                    fixed=False,
+                )
+                issues.append(issue)
+            elif code == "F841":
+                # Unused variable
+                # Extract variable name from message like "Local variable `x` is assigned to but never used"
+                name = message.split("`")[1] if "`" in message else None
+                issue = DeadCodeIssue(
+                    type="unused_variable",
+                    file=filename,
+                    line=line,
+                    name=name,
+                    severity="safe",
+                    fixed=False,
+                )
+                issues.append(issue)
+
+        return issues

wl_cli/commands/clean/dead_code/fixer.py

@@ -0,0 +1,176 @@
+"""
+Dead code fixer module.
+Handles automatic fixing of dead code issues using Ruff.
+"""
+
+from pathlib import Path
+
+from ....utils.logging import log_error_pair
+from ....utils.subprocess_utils import SubprocessExecutor, SubprocessResult
+from .reporter import DeadCodeIssue
+
+
+class DeadCodeFixer:
+    """Fixer for dead code issues."""
+
+    def __init__(self) -> None:
+        """Initialize the dead code fixer."""
+        self.executor = SubprocessExecutor()
+
+    def fix(
+        self, issues: list[DeadCodeIssue], project_root: Path, dry_run: bool = False
+    ) -> list[DeadCodeIssue]:
+        """
+        Fix dead code issues.
+
+        Args:
+            issues: List of DeadCodeIssue objects.
+            project_root: Root directory of the project.
+            dry_run: Whether to only preview fixes without applying them.
+
+        Returns:
+            List of DeadCodeIssue objects with fixed flag updated.
+        """
+        # Only fix safe issues (unused imports and variables)
+        safe_issues = [issue for issue in issues if issue.severity == "safe"]
+
+        if not safe_issues:
+            return issues
+
+        # Run Ruff with --fix (or not in dry-run)
+        result = self._run_ruff_fix(project_root, dry_run)
+
+        # Check if Ruff is not installed. ``--fix`` still exits 1 when it
+        # *repaired* something (or has repairs left to make), so the exit code
+        # alone cannot tell "Ruff ran and worked" from "Ruff never ran" -- see
+        # :meth:`_ruff_unavailable`, the same discriminator the detector uses
+        # (#150/#153).
+        if self._ruff_unavailable(result):
+            log_error_pair(
+                "Ruff is not installed. Please install Ruff to use dead code fixing.",
+                "Ruff 未安装。请安装 Ruff 以使用死代码修复功能。",
+            )
+            return issues
+
+        # Ruff is installed but it did *not* run to completion: any exit other
+        # than 0 (clean) or 1 (ran, and has findings) is a failure -- a bad
+        # config, an unusable argument -- that happened before a single repair
+        # was attempted. Falling through would be worse than useless: the next
+        # step, :meth:`_determine_fixed_issues`, re-runs the *detector*, which
+        # fails the same way and reports nothing left, so every safe issue would
+        # be re-labelled ``fixed`` with no repair behind it (#155 M1). Before
+        # #153 the coarse ``returncode != 0`` test happened to cover this path;
+        # the narrowed discriminator needs this branch to cover it again.
+        if result.returncode not in (0, 1):
+            log_error_pair(
+                f"Ruff failed with exit code {result.returncode}; nothing was fixed.",
+                f"Ruff 运行失败，退出码 {result.returncode}；未修复任何死代码。",
+            )
+            return issues
+
+        if dry_run:
+            # In dry-run mode, we can't know exactly what was fixed,
+            # so we just return the issues as is
+            return issues
+
+        # Determine which issues were fixed by comparing with a fresh detection
+        fixed_issues = self._determine_fixed_issues(issues, project_root)
+
+        return fixed_issues
+
+    def _run_ruff_fix(self, project_root: Path, dry_run: bool) -> SubprocessResult:
+        """
+        Run Ruff fix command.
+
+        Args:
+            project_root: Root directory of the project.
+            dry_run: Whether to only preview fixes.
+
+        Returns:
+            SubprocessResult from Ruff execution.
+        """
+        cmd = ["ruff", "check", "--select", "F401,F841"]
+
+        if not dry_run:
+            cmd.append("--fix")
+
+        cmd.append(".")
+
+        return self.executor.run(command=cmd, cwd=project_root, quiet=True)
+
+    @staticmethod
+    def _ruff_unavailable(result: SubprocessResult) -> bool:
+        """Whether the ``ruff`` process never got as far as repairing anything.
+
+        Deliberately **not** ``returncode != 0``: ``ruff check --fix`` exits
+        **1** whenever it repaired something, still has unfixable findings, or
+        both -- so the old test short-circuited the fix path exactly when Ruff
+        had done its job, and no repaired issue was ever counted as ``fixed``
+        (#153, the sibling of the detector's #150). The discriminator is
+        :attr:`SubprocessResult.launch_error`, the field set only when the
+        executable could not be started at all (#100/#101). ``127`` is kept as
+        a belt-and-braces spelling of a shell's "command not found", which Ruff
+        itself never returns.
+
+        The former ``"not found" in stderr`` sniff is gone with it: a substring
+        of a child's *stderr* cannot distinguish "no such tool" from a Ruff that
+        ran and exited 1.
+
+        This predicate is spelled out identically on :class:`DeadCodeDetector`,
+        and a third copy of the same rule guards the ``uv`` launcher in
+        ``commands/format/python_formatter.py``. Sharing one helper was weighed
+        for #155 (M2) and recorded, not done: the two-line body is the whole
+        function, the three call sites sit in two unrelated packages (so no
+        single home reads naturally -- the ``uv`` site is not about Ruff at
+        all), and the only package-neutral home, ``utils/subprocess_utils.py``,
+        is outside the files #155 touches.
+
+        Args:
+            result: The finished Ruff subprocess result.
+
+        Returns:
+            True when Ruff never produced a report.
+        """
+        if result.launch_error is not None:
+            return True
+        return result.returncode == 127
+
+    def _determine_fixed_issues(
+        self, original_issues: list[DeadCodeIssue], project_root: Path
+    ) -> list[DeadCodeIssue]:
+        """
+        Determine which issues were fixed by running detection again.
+
+        Args:
+            original_issues: Original list of issues.
+            project_root: Root directory of the project.
+
+        Returns:
+            List of issues with fixed flag updated.
+        """
+        from .detector import DeadCodeDetector
+
+        detector = DeadCodeDetector()
+        new_issues = detector.detect(project_root)
+
+        # Create a set of remaining issues for quick lookup
+        remaining_issues_set = set()
+        for issue in new_issues:
+            key = (issue.type, issue.file, issue.line, issue.name)
+            remaining_issues_set.add(key)
+
+        # Mark issues that are not in remaining_issues_set as fixed
+        result = []
+        for issue in original_issues:
+            key = (issue.type, issue.file, issue.line, issue.name)
+            issue_copy = DeadCodeIssue(
+                type=issue.type,
+                file=issue.file,
+                line=issue.line,
+                name=issue.name,
+                severity=issue.severity,
+                fixed=(key not in remaining_issues_set and issue.severity == "safe"),
+            )
+            result.append(issue_copy)
+
+        return result