py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/debug/debug.py

@@ -0,0 +1,309 @@
+"""wl-debug command implementation - code quality validation with smart caching."""
+
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import click
+
+from wl_cli.commands.debug.debug_cache import DebugCache
+from wl_cli.commands.debug.debug_subagent import DebugSubagent
+from wl_cli.commands.debug.output_formatter import OutputFormatter
+from wl_cli.commands.debug.source_hasher import SourceHasher
+
+from ...utils.root import RootKind
+from ...utils.root_fallback import current_root
+
+
+class DebugCommand:
+    """Implementation of the wl-debug command."""
+
+    def __init__(
+        self,
+        json_mode: bool = False,
+        verbosity: int = 0,
+        subagent_mode: bool = False,
+    ):
+        """Initialize debug command.
+
+        Args:
+            json_mode: Enable JSON output mode
+            verbosity: Verbosity level (0-2)
+            subagent_mode: Enable subagent auto-fix mode
+        """
+        self.source_hasher = SourceHasher()
+        self.debug_cache = DebugCache()
+        self.formatter = OutputFormatter(json_mode=json_mode, verbosity=verbosity)
+        self.subagent_mode = subagent_mode
+        self.subagent = DebugSubagent()
+        self.subagent.enabled = subagent_mode
+
+    @property
+    def name(self) -> str:
+        return "debug"
+
+    @property
+    def help(self) -> str:
+        return "Run code quality validation (DEPRECATED: use 'wl test -s' + 'wl format -s')"
+
+    def _run_command(
+        self, cmd: list[str], capture_output: bool = False
+    ) -> int | tuple[int, str, str]:
+        """Run a command and return exit code. For internal use, also returns stdout/stderr."""
+        try:
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, errors="replace"
+            )
+            if result.stdout and not capture_output:
+                self.formatter.info(result.stdout, verbosity=1)
+            if result.stderr and not capture_output:
+                # Error messages should be shown even at default verbosity (0)
+                self.formatter.error(result.stderr, verbosity=0)
+            if capture_output:
+                return result.returncode, result.stdout or "", result.stderr or ""
+            return result.returncode
+        except FileNotFoundError:
+            self.formatter.error(f"Command not found: {cmd[0]}")
+            if capture_output:
+                return 1, "", f"Command not found: {cmd[0]}"
+            return 1
+
+    def _run_command_with_retry(self, cmd: list[str], command_name: str) -> int:
+        """Run a command with retry logic using subagent if enabled.
+
+        Args:
+            cmd: Command to run
+            command_name: Name of the command for logging
+
+        Returns:
+            Exit code (0 on success)
+        """
+        attempt = 0
+        max_total_attempts = 1 + (
+            DebugSubagent.MAX_ATTEMPTS if self.subagent_mode else 0
+        )
+        exit_code = 1
+
+        while attempt < max_total_attempts:
+            # Always use capture_output=True for retry logic to get full output
+            result = self._run_command(cmd, capture_output=True)
+            if isinstance(result, tuple):
+                exit_code, stdout, stderr = result
+            else:
+                exit_code = result
+                stdout = ""
+                stderr = ""
+
+            if exit_code == 0:
+                if stdout:
+                    self.formatter.info(stdout, verbosity=1)
+                return 0
+
+            attempt += 1
+
+            # When command fails, show both stdout and stderr, at verbosity 0
+            if stdout:
+                self.formatter.info(stdout, verbosity=0)
+            if stderr:
+                self.formatter.error(stderr, verbosity=0)
+
+            if not self.subagent_mode:
+                return exit_code
+
+            error_info = self.subagent.record_error(
+                command=" ".join(cmd),
+                exit_code=exit_code,
+                stdout=stdout,
+                stderr=stderr,
+                context={"command_name": command_name, "attempt": attempt},
+            )
+
+            if not self.subagent.can_attempt_fix():
+                self.formatter.error(
+                    f"{command_name} failed and max fix attempts reached"
+                )
+                return exit_code
+
+            self.formatter.info(
+                f"{command_name} failed, attempting fix (attempt {attempt}/{DebugSubagent.MAX_ATTEMPTS})..."
+            )
+
+            fix_result = self.subagent.attempt_fix(
+                error_info,
+                simulate_success=False,
+            )
+
+            self.formatter.info(fix_result.message)
+
+            if fix_result.success:
+                self.formatter.success("Fix applied, retrying...")
+            else:
+                self.formatter.info("No fix available, stopping...")
+                return exit_code
+
+        return exit_code
+
+    def _clean_test_cache(self) -> None:
+        """Clean test cache - delete cache directories directly."""
+        import shutil
+
+        try:
+            # Root-anchored (#125): the project root's ``.wl`` (the DebugCache
+            # anchor), not the process CWD's.
+            project_test_cache = (
+                current_root(RootKind.PROJECT).wl_dir() / "cache" / "test-cache"
+            )
+            if project_test_cache.exists():
+                shutil.rmtree(project_test_cache, ignore_errors=True)
+
+            user_test_cache = Path.home() / ".cache/wl/test-cache"
+            if user_test_cache.exists():
+                shutil.rmtree(user_test_cache, ignore_errors=True)
+        except Exception:
+            pass
+
+    def _clean_format_cache(self) -> None:
+        """Clean format cache - the legacy file and the per-entry store.
+
+        The format cache is per-entry files under ``cache/format/`` since
+        ADR-0011; the single ``format_cache.json`` is the pre-#213 shape. A
+        debug run must clear both, or a stale verdict from the live store
+        survives the clean (#213 review LOW-4).
+        """
+        import shutil
+
+        try:
+            # Root-anchored (#125): the project root's ``.wl``.
+            cache_dir = current_root(RootKind.PROJECT).wl_dir() / "cache"
+            legacy_format_cache = cache_dir / "format_cache.json"
+            if legacy_format_cache.exists():
+                legacy_format_cache.unlink(missing_ok=True)
+
+            format_entries = cache_dir / "format"
+            if format_entries.exists():
+                shutil.rmtree(format_entries, ignore_errors=True)
+        except Exception:
+            pass
+
+    def _run_wl_test(self) -> int:
+        """Run the test suite."""
+        self.formatter.info("Running tests...")
+        return self._run_command_with_retry(["wl", "test", "-s"], "Tests")
+
+    def _run_wl_format(self) -> int:
+        """Check code formatting."""
+        self.formatter.info("Checking formatting...")
+        return self._run_command_with_retry(["wl", "format", "-s"], "Formatting")
+
+    def execute(self) -> int:
+        """Execute the debug validation flow.
+
+        Returns:
+            Exit code (0 on success, non-zero on failure)
+        """
+        if not self.formatter.json_mode:
+            print("========================================")
+            print("     🧪 wl-debug Code Quality Check     ")
+            print("========================================")
+
+        exit_code = 0
+
+        try:
+            source_hash = self.source_hasher.compute_hash()
+        except Exception:
+            source_hash = None
+            self.formatter.info(
+                "Failed to compute source hash, running full validation..."
+            )
+
+        cache_needs_cleaning = True
+
+        if source_hash is not None:
+            cache_data = self.debug_cache.load()
+            if cache_data is not None and cache_data.get("source_hash") == source_hash:
+                self.formatter.success("Code unchanged, using cached results")
+                cache_needs_cleaning = False
+
+        if cache_needs_cleaning:
+            self.formatter.info("Cleaning caches...")
+            self._clean_test_cache()
+            self._clean_format_cache()
+
+        exit_code = self._run_wl_test()
+        if exit_code != 0:
+            self.formatter.error("Tests failed - stopping validation")
+            self.formatter.finalize(success=False, exit_code=exit_code)
+            return exit_code
+
+        exit_code = self._run_wl_format()
+        if exit_code != 0:
+            self.formatter.error("Formatting issues found")
+            self.formatter.finalize(success=False, exit_code=exit_code)
+            return exit_code
+
+        if source_hash is not None:
+            self.debug_cache.save(
+                {
+                    "source_hash": source_hash,
+                    "last_validated_at": time.time(),
+                    "success": True,
+                }
+            )
+
+        if not self.formatter.json_mode:
+            print("========================================")
+            print("✅ All checks passed!")
+            print("========================================")
+
+        self.formatter.finalize(success=True, exit_code=exit_code)
+
+        return exit_code
+
+
+@click.command()
+@click.option(
+    "--json",
+    is_flag=True,
+    help="Enable JSON output mode",
+)
+@click.option(
+    "--subagent",
+    is_flag=True,
+    help="EXPERIMENTAL simulated auto-fix (records errors only; no real fixes yet)",
+)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Increase verbosity (can be used multiple times)",
+)
+@click.option(
+    "-q",
+    "--quiet",
+    count=True,
+    help="Decrease verbosity",
+)
+@click.pass_context
+def debug_command(
+    ctx: click.Context,
+    json: bool,
+    subagent: bool,
+    verbose: int,
+    quiet: int,
+) -> None:
+    """DEPRECATED: scheduled for removal.
+
+    Prefer the supported quality gates `wl test -s` and `wl format -s`
+    (the flow used by the wlcc ``wl-debug`` skill). ``--subagent`` is
+    experimental and currently only records errors - it does not fix them.
+    """
+    verbosity = max(0, min(2, verbose - quiet))
+    cmd = DebugCommand(
+        json_mode=json,
+        verbosity=verbosity,
+        subagent_mode=subagent,
+    )
+    exit_code = cmd.execute()
+    if exit_code != 0:
+        sys.exit(exit_code)

wl_cli/commands/debug/debug_cache.py

@@ -0,0 +1,86 @@
+"""Debug cache module."""
+
+import json
+from pathlib import Path
+
+from wl_cli.utils.cache import DiskCache
+
+from ...utils.root import Root, RootKind
+from ...utils.root_fallback import current_root
+
+
+class DebugCache:
+    """Cache manager for debug operations."""
+
+    CACHE_KEY = "debug_cache"
+    #: Cache file name, inside the ``.wl/cache`` directory at the cache's root.
+    CACHE_FILE = "debug_cache.json"
+
+    def __init__(self, project_root: Path | None = None) -> None:
+        # Root-anchored (#125): the *project* root the CWD belongs to, not the
+        # CWD itself (see ``_wl_dir``). Explicit anchors are untouched -- a
+        # relative ``project_root`` still yields a relative ``.wl`` anchor.
+        self.project_root = project_root or current_root(RootKind.PROJECT).path
+        self._disk_cache = DiskCache(cache_dir=str(self._wl_dir() / "cache" / "debug"))
+        # Cache file path for backward compatibility
+        self.cache_path = self._wl_dir() / "cache" / self.CACHE_FILE
+
+    def _wl_dir(self) -> Path:
+        """The ``.wl`` control directory at this cache's root.
+
+        Built from :class:`~wl_cli.utils.root.Root` so the control-directory
+        name has a single definition (#114/#122). The anchor is this cache's
+        ``project_root`` -- exactly the directory the pre-migration code joined
+        ``".wl/cache/..."`` onto, so behaviour is unchanged.
+        """
+        return Root(self.project_root, RootKind.PROJECT).wl_dir()
+
+    def load(self) -> dict | None:
+        """Load cache from file."""
+        try:
+            # First try to load from old JSON for backward compatibility
+            if self.cache_path.exists():
+                with self.cache_path.open("r", encoding="utf-8") as f:
+                    data: dict = json.load(f)
+                # Also save to new format for next time
+                self._disk_cache.set(self.CACHE_KEY, data)
+                return data
+
+            # Fallback to new DiskCache
+            cached_data: dict | None = self._disk_cache.get(self.CACHE_KEY)
+            if cached_data is not None:
+                return cached_data
+
+            return None
+        except Exception:
+            return None
+
+    def save(self, data: dict) -> None:
+        """Save cache to file."""
+        try:
+            # Save in both formats for backward compatibility
+            self._disk_cache.set(self.CACHE_KEY, data)
+            # Also save old JSON format
+            self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+            with self.cache_path.open("w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+        except Exception:
+            pass
+
+    def is_valid(self, current_hash: str) -> bool:
+        """Check if cache is valid for current source hash."""
+        try:
+            cached_data = self.load()
+            if cached_data is None:
+                return False
+            return cached_data.get("source_hash") == current_hash
+        except Exception:
+            return False
+
+    def invalidate(self) -> None:
+        """Invalidate cache by removing the cache entry."""
+        try:
+            self._disk_cache.delete(self.CACHE_KEY)
+            self.cache_path.unlink(missing_ok=True)
+        except Exception:
+            pass

wl_cli/commands/debug/debug_subagent.py

@@ -0,0 +1,156 @@
+"""DebugSubagent - 自动修复子代理实现。
+
+收集和结构化错误信息，提供修复接口。
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ErrorInfo:
+    """结构化错误信息。"""
+
+    command: str
+    exit_code: int
+    stdout: str | None = None
+    stderr: str | None = None
+    context: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FixResult:
+    """修复尝试结果。"""
+
+    attempt: int
+    success: bool
+    message: str
+    error_info: ErrorInfo | None = None
+    context: dict[str, Any] = field(default_factory=dict)
+
+
+class DebugSubagent:
+    """调试子代理 - 收集错误信息并提供修复接口。
+
+    注意：这是一个简单实现，不实际调用 investigate 技能，
+    只用于收集和结构化错误信息，提供接口供外部使用。
+    """
+
+    MAX_ATTEMPTS = 3
+
+    def __init__(self) -> None:
+        """初始化 DebugSubagent。"""
+        self.errors: list[ErrorInfo] = []
+        self.fix_attempts: list[FixResult] = []
+        self.current_attempt = 0
+        self._enabled = False
+
+    @property
+    def enabled(self) -> bool:
+        """检查子代理是否启用。"""
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        """设置子代理启用状态。"""
+        self._enabled = value
+
+    def record_error(
+        self,
+        command: str,
+        exit_code: int,
+        stdout: str | None = None,
+        stderr: str | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> ErrorInfo:
+        """记录一个错误。
+
+        Args:
+            command: 失败的命令
+            exit_code: 退出码
+            stdout: 标准输出
+            stderr: 标准错误
+            context: 附加上下文信息
+
+        Returns:
+            结构化的错误信息
+        """
+        error_info = ErrorInfo(
+            command=command,
+            exit_code=exit_code,
+            stdout=stdout,
+            stderr=stderr,
+            context=context or {},
+        )
+        self.errors.append(error_info)
+        return error_info
+
+    def can_attempt_fix(self) -> bool:
+        """检查是否可以尝试修复。
+
+        Returns:
+            如果可以尝试修复返回 True，否则返回 False
+        """
+        return self._enabled and self.current_attempt < self.MAX_ATTEMPTS
+
+    def attempt_fix(
+        self,
+        error_info: ErrorInfo,
+        simulate_success: bool = False,
+    ) -> FixResult:
+        """尝试修复错误。
+
+        注意：这是一个模拟实现，不实际执行修复操作。
+        在完整实现中，这里会调用 investigate 技能。
+
+        Args:
+            error_info: 要修复的错误信息
+            simulate_success: 是否模拟修复成功（用于测试）
+
+        Returns:
+            修复尝试结果
+        """
+        self.current_attempt += 1
+
+        success = simulate_success
+        message = (
+            "Simulated fix successful (for testing)"
+            if success
+            else "Fix attempt failed - max attempts reached or no fix available"
+        )
+
+        result = FixResult(
+            attempt=self.current_attempt,
+            success=success,
+            message=message,
+            error_info=error_info,
+            context={
+                "simulated": True,
+                "max_attempts": self.MAX_ATTEMPTS,
+            },
+        )
+
+        self.fix_attempts.append(result)
+        return result
+
+    def reset(self) -> None:
+        """重置子代理状态。"""
+        self.errors.clear()
+        self.fix_attempts.clear()
+        self.current_attempt = 0
+
+    def get_summary(self) -> dict[str, Any]:
+        """获取子代理活动摘要。
+
+        Returns:
+            包含活动摘要的字典
+        """
+        return {
+            "enabled": self._enabled,
+            "errors_recorded": len(self.errors),
+            "fix_attempts_made": len(self.fix_attempts),
+            "successful_fixes": sum(1 for r in self.fix_attempts if r.success),
+            "failed_fixes": sum(1 for r in self.fix_attempts if not r.success),
+            "current_attempt": self.current_attempt,
+            "max_attempts": self.MAX_ATTEMPTS,
+        }