py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/clean/dead_code/reporter.py

@@ -0,0 +1,295 @@
+"""Dead code reporter module.
+Handles reporting for dead code cleanup command.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class DeadCodeIssue:
+    """Data structure for a dead code issue."""
+
+    type: str
+    file: str
+    line: int | None
+    name: str | None
+    severity: str
+    fixed: bool
+
+
+@dataclass
+class TestSuggestion:
+    """Data structure for a test suggestion."""
+
+    function: str | None
+    file: str
+    line: int | None
+    suggestion: str
+    suggestion_zh: str
+
+
+@dataclass
+class ReportSummary:
+    """Data structure for the report summary."""
+
+    total_issues: int
+    auto_fixed: int
+    manual_required: int
+    test_suggestions: int
+
+
+class DeadCodeReporter:
+    """Reporter for dead code cleanup command."""
+
+    def __init__(self) -> None:
+        """Initialize the reporter.
+
+        Language is not a constructor input: every message goes through
+        ``log_*_pair``, which picks the variant itself (#167).
+        """
+        self._import_logger()
+
+    def _import_logger(self) -> None:
+        """Lazy import the logging functions."""
+        from wl_cli.utils.logging import (
+            log_info_pair,
+            log_warning_pair,
+        )
+
+        self.log_info_pair = log_info_pair
+        self.log_warning_pair = log_warning_pair
+
+    def report_cli(
+        self,
+        issues: list[DeadCodeIssue],
+        test_suggestions: list[TestSuggestion],
+        dry_run: bool = False,
+    ) -> None:
+        """Generate CLI output report.
+
+        Args:
+            issues: List of dead code issues.
+            test_suggestions: List of test suggestions.
+            dry_run: Whether this is a dry run.
+        """
+        summary = self._calculate_summary(issues, test_suggestions)
+        self._report_scanning()
+        self._report_total_issues(summary)
+        self._report_auto_fixed(issues)
+        if dry_run:
+            self._report_dry_run_issues(issues)
+        self._report_manual_required(issues)
+        self._report_test_suggestions(test_suggestions)
+        self._report_completion(summary)
+
+    def _report_dry_run_issues(self, issues: list[DeadCodeIssue]) -> None:
+        """Report issues that would be fixed in dry run mode.
+
+        Args:
+            issues: List of dead code issues.
+        """
+        dry_run_issues = [issue for issue in issues if issue.severity == "safe"]
+        if dry_run_issues:
+            self.log_info_pair(
+                "Would fix (safe operations - dry run):",
+                "将修复（安全操作 - 试运行）：",
+            )
+            for issue in dry_run_issues:
+                self._report_single_issue(issue)
+
+    def report_json(
+        self,
+        issues: list[DeadCodeIssue],
+        test_suggestions: list[TestSuggestion],
+    ) -> str:
+        """Generate JSON output report.
+
+        Args:
+            issues: List of dead code issues.
+            test_suggestions: List of test suggestions.
+
+        Returns:
+            JSON string of the report.
+        """
+        summary = self._calculate_summary(issues, test_suggestions)
+
+        json_data = {
+            "summary": {
+                "total_issues": summary.total_issues,
+                "auto_fixed": summary.auto_fixed,
+                "manual_required": summary.manual_required,
+                "test_suggestions": summary.test_suggestions,
+            },
+            "issues": [self._issue_to_dict(issue) for issue in issues],
+            "test_suggestions": [
+                self._suggestion_to_dict(suggestion) for suggestion in test_suggestions
+            ],
+        }
+
+        return json.dumps(json_data, ensure_ascii=False, indent=2)
+
+    def _calculate_summary(
+        self,
+        issues: list[DeadCodeIssue],
+        test_suggestions: list[TestSuggestion],
+    ) -> ReportSummary:
+        """Calculate the report summary.
+
+        Args:
+            issues: List of dead code issues.
+            test_suggestions: List of test suggestions.
+
+        Returns:
+            ReportSummary object.
+        """
+        total_issues = len(issues)
+        auto_fixed = sum(1 for issue in issues if issue.fixed)
+        manual_required = sum(
+            1 for issue in issues if not issue.fixed and issue.severity != "safe"
+        )
+
+        return ReportSummary(
+            total_issues=total_issues,
+            auto_fixed=auto_fixed,
+            manual_required=manual_required,
+            test_suggestions=len(test_suggestions),
+        )
+
+    def _report_scanning(self) -> None:
+        """Report that scanning is in progress."""
+        self.log_info_pair("Scanning for dead code...", "正在扫描死代码...")
+
+    def _report_total_issues(self, summary: ReportSummary) -> None:
+        """Report the total number of issues found.
+
+        Args:
+            summary: Report summary.
+        """
+        if summary.total_issues > 0:
+            self.log_info_pair(
+                f"Found {summary.total_issues} issues.",
+                f"发现 {summary.total_issues} 个问题。",
+            )
+        else:
+            self.log_info_pair("No dead code issues found.", "未发现死代码问题。")
+
+    def _report_auto_fixed(self, issues: list[DeadCodeIssue]) -> None:
+        """Report the auto-fixed issues.
+
+        Args:
+            issues: List of dead code issues.
+        """
+        auto_fixed_issues = [issue for issue in issues if issue.fixed]
+        if auto_fixed_issues:
+            self.log_info_pair(
+                "Auto-fixed (safe operations):", "自动修复（安全操作）："
+            )
+            for issue in auto_fixed_issues:
+                self._report_single_issue(issue)
+
+    def _report_manual_required(self, issues: list[DeadCodeIssue]) -> None:
+        """Report the issues that require manual confirmation.
+
+        Args:
+            issues: List of dead code issues.
+        """
+        manual_issues = [
+            issue for issue in issues if not issue.fixed and issue.severity != "safe"
+        ]
+        if manual_issues:
+            self.log_warning_pair("Requires manual review:", "需要手动确认：")
+            for issue in manual_issues:
+                self._report_single_issue(issue)
+
+    def _report_single_issue(self, issue: DeadCodeIssue) -> None:
+        """Report a single issue.
+
+        Args:
+            issue: Dead code issue.
+        """
+        if issue.type == "unused_import":
+            self.log_info_pair(
+                f"  - Removed unused import: {issue.name} ({issue.file}:{issue.line})",
+                f"  - 移除未使用的导入: {issue.name} ({issue.file}:{issue.line})",
+            )
+        elif issue.type == "unused_variable":
+            self.log_info_pair(
+                f"  - Removed unused variable: {issue.name} ({issue.file}:{issue.line})",
+                f"  - 移除未使用的变量: {issue.name} ({issue.file}:{issue.line})",
+            )
+        elif issue.type == "possibly_abandoned_module":
+            self.log_warning_pair(
+                f"  - Possibly abandoned module: {issue.file} (0 importers)",
+                f"  - 可能是废弃模块: {issue.file} (0 个导入者)",
+            )
+        elif issue.type == "no_test_coverage":
+            self.log_warning_pair(
+                f"  - Function without test coverage: {issue.name} ({issue.file}:{issue.line})",
+                f"  - 无测试覆盖的函数: {issue.name} ({issue.file}:{issue.line})",
+            )
+        else:
+            self.log_info_pair(
+                f"  - {issue.type}: {issue.name} ({issue.file}:{issue.line})",
+                f"  - {issue.type}: {issue.name} ({issue.file}:{issue.line})",
+            )
+
+    def _report_test_suggestions(self, test_suggestions: list[TestSuggestion]) -> None:
+        """Report test suggestions.
+
+        Args:
+            test_suggestions: List of test suggestions.
+        """
+        if test_suggestions:
+            self.log_info_pair("Test suggestions:", "测试建议：")
+            for suggestion in test_suggestions:
+                self.log_info_pair(
+                    f"  - {suggestion.suggestion}", f"  - {suggestion.suggestion_zh}"
+                )
+
+    def _report_completion(self, summary: ReportSummary) -> None:
+        """Report scan completion.
+
+        Args:
+            summary: Report summary.
+        """
+        self.log_info_pair(
+            f"Scan complete: {summary.auto_fixed} fixed, {summary.manual_required} manual required",
+            f"扫描完成：修复 {summary.auto_fixed} 个，待手动处理 {summary.manual_required} 个",
+        )
+
+    def _issue_to_dict(self, issue: DeadCodeIssue) -> dict[str, Any]:
+        """Convert a DeadCodeIssue to a dictionary.
+
+        Args:
+            issue: Dead code issue.
+
+        Returns:
+            Dictionary representation of the issue.
+        """
+        return {
+            "type": issue.type,
+            "file": issue.file,
+            "line": issue.line,
+            "name": issue.name,
+            "severity": issue.severity,
+            "fixed": issue.fixed,
+        }
+
+    def _suggestion_to_dict(self, suggestion: TestSuggestion) -> dict[str, Any]:
+        """Convert a TestSuggestion to a dictionary.
+
+        Args:
+            suggestion: Test suggestion.
+
+        Returns:
+            Dictionary representation of the suggestion.
+        """
+        return {
+            "function": suggestion.function,
+            "file": suggestion.file,
+            "line": suggestion.line,
+            "suggestion": suggestion.suggestion,
+            "suggestion_zh": suggestion.suggestion_zh,
+        }

wl_cli/commands/clean/lfs.py

@@ -0,0 +1,215 @@
+"""
+Git LFS Cleaner
+Git LFS清理器
+
+This module handles cleaning of Git LFS deployment artifacts.
+此模块处理Git LFS部署产物的清理。
+"""
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from wl_cli.utils.logging import log_info_pair
+
+from ...utils.root import RootKind
+from ...utils.root_fallback import current_root
+
+
+def clean_lfs_artifacts(dry_run: bool = False, config: str | None = None) -> None:
+    """
+    Clean Git LFS deployment without deleting actual files
+    清理Git LFS部署，不删除实际文件
+    """
+    log_info_pair("Cleaning Git LFS deployment...", "正在清理Git LFS部署...")
+
+    # 检查并移除嵌套的.git目录
+    _handle_nested_git_dirs(dry_run=dry_run)
+
+    # 清理.gitattributes文件中的LFS跟踪规则
+    _clean_gitattributes(dry_run=dry_run)
+
+    # 清理LFS lock配置文件
+    _clean_lock_config(dry_run=dry_run)
+
+    # 卸载Git LFS钩子
+    _uninstall_git_lfs()
+
+    log_info_pair("Git LFS deployment cleaning completed.", "Git LFS部署清理完成。")
+
+
+def _find_nested_git_dirs() -> list[Path]:
+    """查找嵌套的.git目录（不包括根目录的.git）"""
+    current_dir = Path.cwd()
+    nested_git_dirs = []
+
+    for git_dir in current_dir.glob("**/.git"):
+        # 跳过根目录的.git文件夹
+        if git_dir.parent == current_dir:
+            continue
+        # 检查是否是目录
+        if git_dir.is_dir():
+            nested_git_dirs.append(git_dir)
+
+    return nested_git_dirs
+
+
+def _remove_nested_git_dirs(nested_git_dirs: list[Path], dry_run: bool = False) -> None:
+    """移除嵌套的.git目录"""
+    log_info_pair(
+        "\nAutomatically removing nested .git directories...",
+        "\n正在自动移除嵌套的.git目录...",
+    )
+
+    for git_dir in nested_git_dirs:
+        try:
+            if dry_run:
+                log_info_pair(f"✓ Would remove: {git_dir}", f"✓ 将移除: {git_dir}")
+            else:
+                shutil.rmtree(git_dir)
+                log_info_pair(
+                    f"✓ Successfully removed: {git_dir}", f"✓ 成功移除: {git_dir}"
+                )
+        except Exception as e:
+            log_info_pair(
+                f"✗ Failed to remove {git_dir}: {e}", f"✗ 移除失败 {git_dir}: {e}"
+            )
+
+
+def _handle_nested_git_dirs(dry_run: bool = False) -> None:
+    """处理嵌套的.git目录"""
+    log_info_pair(
+        "Checking for nested .git directories...", "正在检查嵌套的.git目录..."
+    )
+
+    nested_git_dirs = _find_nested_git_dirs()
+
+    if nested_git_dirs:
+        log_info_pair(
+            "Found nested .git directories, removing them to fix Git operations:",
+            "发现嵌套的.git目录，正在移除它们以修复Git操作：",
+        )
+
+        for git_dir in nested_git_dirs:
+            log_info_pair(f"  - {git_dir}", f"  - {git_dir}")
+
+        _remove_nested_git_dirs(nested_git_dirs, dry_run=dry_run)
+    else:
+        log_info_pair("✓ No nested .git directories found", "✓ 未发现嵌套的.git目录")
+
+
+def _clean_gitattributes(dry_run: bool = False) -> None:
+    """清理.gitattributes文件中的LFS跟踪规则"""
+    gitattributes_path = Path(".gitattributes")
+    if gitattributes_path.exists():
+        log_info_pair(
+            "Removing Git LFS tracking rules from .gitattributes...",
+            "正在从.gitattributes中移除Git LFS跟踪规则...",
+        )
+
+        # Read the current content
+        with open(gitattributes_path) as f:
+            lines = f.readlines()
+
+        # Filter out Git LFS tracking rules
+        filtered_lines = []
+        for line in lines:
+            # Check if the line contains Git LFS tracking rules
+            if (
+                "filter=lfs" not in line
+                and "diff=lfs" not in line
+                and "merge=lfs" not in line
+            ):
+                filtered_lines.append(line)
+
+        # Write back the filtered content if not in dry run mode
+        if dry_run:
+            log_info_pair(
+                "✓ Would update .gitattributes to remove LFS tracking rules",
+                "✓ 将更新.gitattributes以移除LFS跟踪规则",
+            )
+        else:
+            with open(gitattributes_path, "w") as f:
+                f.writelines(filtered_lines)
+            log_info_pair(
+                "✓ Removed Git LFS tracking rules from .gitattributes",
+                "✓ 已从.gitattributes中移除Git LFS跟踪规则",
+            )
+
+
+def _uninstall_git_lfs() -> None:
+    """卸载Git LFS钩子"""
+    log_info_pair("Removing Git LFS hooks...", "正在移除Git LFS钩子...")
+
+    try:
+        result = subprocess.run(
+            ["git", "lfs", "uninstall"], check=True, capture_output=True, text=True
+        )
+
+        # Filter out warning messages from both stdout and stderr
+        def filter_warnings(output):
+            if not output:
+                return ""
+            lines = output.strip().split("\n")
+            filtered_lines = [line for line in lines if not line.startswith("warning:")]
+            return "\n".join(filtered_lines).strip()
+
+        # Filter both stdout and stderr
+        filtered_stdout = filter_warnings(result.stdout)
+        filtered_stderr = filter_warnings(result.stderr)
+
+        # Combine filtered outputs if both exist
+        combined_output = ""
+        if filtered_stdout:
+            combined_output = filtered_stdout
+        if filtered_stderr:
+            if combined_output:
+                combined_output += f"\n{filtered_stderr}"
+            else:
+                combined_output = filtered_stderr
+
+        # Only log if there's meaningful output, otherwise just confirm success
+        if combined_output:
+            log_info_pair(
+                f"✓ Git LFS hooks removed: {combined_output}",
+                f"✓ Git LFS钩子已移除: {combined_output}",
+            )
+        else:
+            log_info_pair("✓ Git LFS hooks removed", "✓ Git LFS钩子已移除")
+    except subprocess.CalledProcessError as e:
+        # Filter warnings from stderr in case of error too
+        stderr_msg = e.stderr.strip() if e.stderr else "Unknown error"
+        filtered_stderr = ""
+        if stderr_msg:
+            lines = stderr_msg.split("\n")
+            filtered_lines = [line for line in lines if not line.startswith("warning:")]
+            filtered_stderr = "\n".join(filtered_lines).strip()
+        log_info_pair(
+            f"✗ Failed to remove Git LFS hooks: {filtered_stderr or stderr_msg}",
+            f"✗ 移除Git LFS钩子失败: {filtered_stderr or stderr_msg}",
+        )
+
+
+def _clean_lock_config(dry_run: bool = False) -> None:
+    """Remove the project root's ``.wl/lfs-lock.yml`` if it exists.
+
+    Before #125 the ``.wl`` here was anchored to the **process working
+    directory** -- a bare relative ``Path(".wl")`` -- so ``wl clean`` from a
+    subdirectory looked for the *subdirectory's* lock config and left the root's
+    in place. #125 (the CWD-anchored -> root-anchored behaviour change, per the
+    #121 ruling) anchors it at the project root instead; see ADR 0006. The
+    ``PROJECT`` kind matches the LFS initializer that writes the file.
+    """
+    lock_config_path = current_root(RootKind.PROJECT).wl_dir() / "lfs-lock.yml"
+    if not lock_config_path.exists():
+        return
+
+    log_info_pair("Removing LFS lock configuration...", "正在移除LFS lock配置...")
+
+    if dry_run:
+        log_info_pair(
+            f"✓ Would remove: {lock_config_path}", f"✓ 将移除: {lock_config_path}"
+        )
+    else:
+        lock_config_path.unlink()
+        log_info_pair("✓ LFS lock configuration removed", "✓ LFS lock配置已移除")

wl_cli/commands/clean/python.py

@@ -0,0 +1,81 @@
+"""
+Python-specific cleaning utilities for clean command.
+"""
+
+import glob
+import os
+import shutil
+from pathlib import Path
+
+from wl_cli.utils.logging import log_info_pair
+
+
+def remove_log_files(dry_run: bool = False) -> None:
+    """Remove log files."""
+    try:
+        for log_file in glob.glob("*.log"):
+            if dry_run:
+                log_info_pair(
+                    f"Would remove log file: {log_file}", f"将删除日志文件: {log_file}"
+                )
+            else:
+                os.remove(log_file)
+                log_info_pair(
+                    f"Removed log file: {log_file}", f"已删除日志文件: {log_file}"
+                )
+    except Exception as e:
+        log_info_pair(f"Failed to remove log files: {e}", f"删除日志文件失败: {e}")
+
+
+def remove_pycache_dirs(dry_run: bool = False) -> None:
+    """Remove __pycache__ directories only in project directory (not in venv)."""
+    try:
+        project_root = Path(".").resolve()
+        for pycache_dir in project_root.rglob("__pycache__"):
+            # Skip pycache directories in virtual environments
+            if ".venv" in str(pycache_dir) or "venv" in str(pycache_dir):
+                continue
+
+            if pycache_dir.is_dir():
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove pycache directory: {pycache_dir}",
+                        f"将删除pycache目录: {pycache_dir}",
+                    )
+                else:
+                    shutil.rmtree(pycache_dir)
+                    log_info_pair(
+                        f"Removed pycache directory: {pycache_dir}",
+                        f"已删除pycache目录: {pycache_dir}",
+                    )
+    except Exception as e:
+        log_info_pair(
+            f"Failed to remove pycache directories: {e}", f"删除pycache目录失败: {e}"
+        )
+
+
+def remove_egg_info_dirs(dry_run: bool = False) -> None:
+    """Remove egg-info directories only in project directory."""
+    try:
+        project_root = Path(".").resolve()
+        for egg_info_dir in project_root.rglob("*.egg-info"):
+            # Skip egg-info directories in virtual environments
+            if ".venv" in str(egg_info_dir) or "venv" in str(egg_info_dir):
+                continue
+
+            if egg_info_dir.is_dir():
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove egg-info directory: {egg_info_dir}",
+                        f"将删除egg-info目录: {egg_info_dir}",
+                    )
+                else:
+                    shutil.rmtree(egg_info_dir)
+                    log_info_pair(
+                        f"Removed egg-info directory: {egg_info_dir}",
+                        f"已删除egg-info目录: {egg_info_dir}",
+                    )
+    except Exception as e:
+        log_info_pair(
+            f"Failed to remove egg-info directories: {e}", f"删除egg-info目录失败: {e}"
+        )

wl_cli/commands/clean/rust.py

@@ -0,0 +1,91 @@
+"""
+Rust-specific cleaning utilities for clean command.
+"""
+
+import os
+import shutil
+
+from wl_cli.utils.logging import log_info_pair
+
+
+def remove_rust_analyzer_dirs(dry_run: bool = False) -> None:
+    """Remove rust-analyzer directories."""
+    rust_analyzer_dirs = ["target/rust-analyzer", "rust/target/rust-analyzer"]
+    for dir_path in rust_analyzer_dirs:
+        if os.path.exists(dir_path):
+            try:
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove rust-analyzer directory: {dir_path}",
+                        f"将删除rust-analyzer目录: {dir_path}",
+                    )
+                else:
+                    shutil.rmtree(dir_path)
+                    log_info_pair(
+                        f"Removed rust-analyzer directory: {dir_path}",
+                        f"已删除rust-analyzer目录: {dir_path}",
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"Failed to remove rust-analyzer directory {dir_path}: {e}",
+                    f"删除rust-analyzer目录 {dir_path} 失败: {e}",
+                )
+
+
+def clean_rust_artifacts(dry_run: bool = False) -> None:
+    """
+    Clean Rust build artifacts
+    清理Rust构建产物
+    """
+    # Check if Rust is enabled and directory exists
+    rust_dir = "rust"
+    if os.path.exists(rust_dir):
+        rust_target_dir = os.path.join(rust_dir, "target")
+        if os.path.exists(rust_target_dir):
+            try:
+                if dry_run:
+                    log_info_pair(
+                        f"Would remove Rust target directory: {rust_target_dir}",
+                        f"将删除Rust target目录: {rust_target_dir}",
+                    )
+                else:
+                    shutil.rmtree(rust_target_dir)
+                    log_info_pair(
+                        f"Removed Rust target directory: {rust_target_dir}",
+                        f"已删除Rust target目录: {rust_target_dir}",
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"Failed to remove Rust target directory {rust_target_dir}: {e}",
+                    f"删除Rust target目录 {rust_target_dir} 失败: {e}",
+                )
+        else:
+            log_info_pair(
+                "Rust target directory does not exist, skipping...",
+                "Rust target目录不存在，跳过...",
+            )
+    else:
+        log_info_pair(
+            "Rust directory does not exist, skipping...", "Rust目录不存在，跳过..."
+        )
+
+    # Remove rust-analyzer directory in root target
+    root_rust_analyzer_dir = "target/rust-analyzer"
+    if os.path.exists(root_rust_analyzer_dir):
+        try:
+            if dry_run:
+                log_info_pair(
+                    f"Would remove root rust-analyzer directory: {root_rust_analyzer_dir}",
+                    f"将删除根目录rust-analyzer目录: {root_rust_analyzer_dir}",
+                )
+            else:
+                shutil.rmtree(root_rust_analyzer_dir)
+                log_info_pair(
+                    f"Removed root rust-analyzer directory: {root_rust_analyzer_dir}",
+                    f"已删除根目录rust-analyzer目录: {root_rust_analyzer_dir}",
+                )
+        except Exception as e:
+            log_info_pair(
+                f"Failed to remove root rust-analyzer directory {root_rust_analyzer_dir}: {e}",
+                f"删除根目录rust-analyzer目录 {root_rust_analyzer_dir} 失败: {e}",
+            )