crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/adapters/rust_tool_manager.py

@@ -0,0 +1,193 @@
+"""Rust tool manager for unified execution and coordination."""
+
+import asyncio
+import time
+import typing as t
+from pathlib import Path
+
+from .rust_tool_adapter import BaseRustToolAdapter, ToolResult
+from .skylos_adapter import SkylosAdapter
+from .zuban_adapter import ZubanAdapter
+
+if t.TYPE_CHECKING:
+    from crackerjack.orchestration.execution_strategies import ExecutionContext
+
+
+class RustToolHookManager:
+    """Manager for coordinating Rust-based analysis tools."""
+
+    def __init__(self, context: "ExecutionContext") -> None:
+        """Initialize manager with execution context."""
+        self.context = context
+        self.adapters: dict[str, BaseRustToolAdapter] = {}
+        self._initialize_adapters()
+
+    def _initialize_adapters(self) -> None:
+        """Initialize available Rust tool adapters."""
+        # Dead code detection with Skylos
+        self.adapters["skylos"] = SkylosAdapter(context=self.context)
+
+        # Type checking with Zuban
+        self.adapters["zuban"] = ZubanAdapter(context=self.context)
+
+    async def run_all_tools(
+        self, target_files: list[Path] | None = None
+    ) -> dict[str, ToolResult]:
+        """Run all available Rust tools in parallel."""
+        target_files = target_files or []
+
+        # Filter to available tools only
+        available_adapters = {
+            name: adapter
+            for name, adapter in self.adapters.items()
+            if adapter.validate_tool_available()
+        }
+
+        if not available_adapters:
+            return {
+                "error": ToolResult(
+                    success=False,
+                    error=(
+                        "No Rust tools are available. "
+                        "Install skylos and zuban with: uv add skylos zuban"
+                    ),
+                )
+            }
+
+        # Run tools in parallel
+        tasks = [
+            self._run_single_tool(name, adapter, target_files)
+            for name, adapter in available_adapters.items()
+        ]
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Process results
+        tool_results = {}
+        for i, (name, _) in enumerate(available_adapters.items()):
+            result = results[i]
+            if isinstance(result, Exception):
+                tool_results[name] = ToolResult(
+                    success=False,
+                    error=f"Tool execution failed: {result}",
+                )
+            elif isinstance(result, ToolResult):  # Explicit check for mypy
+                tool_results[name] = result
+
+        return tool_results
+
+    async def run_single_tool(
+        self, tool_name: str, target_files: list[Path] | None = None
+    ) -> ToolResult:
+        """Run a single Rust tool by name."""
+        if tool_name not in self.adapters:
+            return ToolResult(
+                success=False,
+                error=(
+                    f"Unknown tool: {tool_name}. "
+                    f"Available: {list[t.Any](self.adapters.keys())}"
+                ),
+            )
+
+        adapter = self.adapters[tool_name]
+        if not adapter.validate_tool_available():
+            return ToolResult(
+                success=False,
+                error=(
+                    f"Tool {tool_name} is not available. "
+                    f"Install with: uv add {tool_name}"
+                ),
+            )
+
+        return await self._run_single_tool(tool_name, adapter, target_files or [])
+
+    async def _run_single_tool(
+        self, name: str, adapter: BaseRustToolAdapter, target_files: list[Path]
+    ) -> ToolResult:
+        """Execute a single tool adapter."""
+        start_time = time.time()
+
+        try:
+            # Get command arguments
+            cmd_args = adapter.get_command_args(target_files)
+
+            # Execute command
+            process = await asyncio.create_subprocess_exec(
+                *cmd_args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                cwd=self.context.working_directory,
+            )
+
+            stdout, _ = await process.communicate()
+            output = stdout.decode() if stdout else ""
+
+            # Parse output
+            result = adapter.parse_output(output)
+            result.execution_time = time.time() - start_time
+
+            return result
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                error=f"Failed to execute {name}: {e}",
+                execution_time=time.time() - start_time,
+                tool_version=adapter.get_tool_version(),
+            )
+
+    def get_available_tools(self) -> list[str]:
+        """Get list[t.Any] of available Rust tools."""
+        return [
+            name
+            for name, adapter in self.adapters.items()
+            if adapter.validate_tool_available()
+        ]
+
+    def get_tool_info(self) -> dict[str, dict[str, t.Any]]:
+        """Get information about all configured tools."""
+        info: dict[str, dict[str, t.Any]] = {}
+        for name, adapter in self.adapters.items():
+            info[name] = {
+                "available": adapter.validate_tool_available(),
+                "supports_json": adapter.supports_json_output(),
+                "version": adapter.get_tool_version(),
+                "tool_name": adapter.get_tool_name(),
+            }
+        return info
+
+    def create_consolidated_report(
+        self, results: dict[str, ToolResult]
+    ) -> dict[str, t.Any]:
+        """Create a consolidated report from multiple tool results."""
+        total_issues = 0
+        total_errors = 0
+        total_warnings = 0
+        all_success = True
+        execution_times = {}
+
+        for tool_name, result in results.items():
+            if tool_name == "error":
+                all_success = False
+                continue
+
+            total_issues += len(result.issues)
+            total_errors += result.error_count
+            total_warnings += result.warning_count
+            execution_times[tool_name] = result.execution_time
+
+            if not result.success:
+                all_success = False
+
+        return {
+            "overall_success": all_success,
+            "total_issues": total_issues,
+            "total_errors": total_errors,
+            "total_warnings": total_warnings,
+            "tools_run": list[t.Any](results.keys()),
+            "execution_times": execution_times,
+            "total_time": sum(execution_times.values()),
+            "results_by_tool": {
+                name: result.to_dict() for name, result in results.items()
+            },
+        }

crackerjack/adapters/skylos_adapter.py

@@ -0,0 +1,231 @@
+"""Skylos adapter for dead code detection."""
+
+import typing as t
+from dataclasses import dataclass
+from pathlib import Path
+
+from .rust_tool_adapter import BaseRustToolAdapter, Issue, ToolResult
+
+if t.TYPE_CHECKING:
+    from crackerjack.orchestration.execution_strategies import ExecutionContext
+
+
+@dataclass
+class DeadCodeIssue(Issue):
+    """Skylos dead code detection issue."""
+
+    severity: str = "warning"  # Override default, dead code is typically warning
+    issue_type: str = "unknown"  # "import", "function", "class", "variable", etc.
+    name: str = "unknown"
+    confidence: float = 0.0
+
+    def to_dict(self) -> dict[str, t.Any]:
+        """Convert issue to dictionary with Skylos-specific fields."""
+        base_dict = super().to_dict()
+        base_dict.update(
+            {
+                "issue_type": self.issue_type,
+                "name": self.name,
+                "confidence": self.confidence,
+            }
+        )
+        return base_dict
+
+
+class SkylosAdapter(BaseRustToolAdapter):
+    """Skylos dead code detection adapter."""
+
+    def __init__(
+        self,
+        context: "ExecutionContext",
+        confidence_threshold: int = 86,
+        web_dashboard_port: int = 5090,
+    ) -> None:
+        """Initialize Skylos adapter."""
+        super().__init__(context)
+        self.confidence_threshold = confidence_threshold
+        self.web_dashboard_port = web_dashboard_port
+
+    def get_tool_name(self) -> str:
+        """Get the name of the tool."""
+        return "skylos"
+
+    def supports_json_output(self) -> bool:
+        """Skylos supports JSON output mode."""
+        return True
+
+    def get_command_args(self, target_files: list[Path]) -> list[str]:
+        """Get command arguments for Skylos execution."""
+        args = ["uv", "run", "skylos", "--confidence", str(self.confidence_threshold)]
+
+        # Add JSON mode for AI agents
+        if self._should_use_json_output():
+            args.append("--json")
+
+        # Add web dashboard for interactive mode
+        if self.context.interactive:
+            args.extend(["--web", "--port", str(self.web_dashboard_port)])
+
+        # Add target files or default to current directory
+        if target_files:
+            args.extend(str(f) for f in target_files)
+        else:
+            args.append(".")
+
+        return args
+
+    def parse_output(self, output: str) -> ToolResult:
+        """Parse Skylos output into standardized result."""
+        if self._should_use_json_output():
+            return self._parse_json_output(output)
+        return self._parse_text_output(output)
+
+    def _parse_json_output(self, output: str) -> ToolResult:
+        """Parse JSON output for AI agents."""
+        data = self._parse_json_output_safe(output)
+        if data is None:
+            return self._create_error_result(
+                "Invalid JSON output from Skylos", raw_output=output
+            )
+
+        try:
+            issues: list[Issue] = [
+                DeadCodeIssue(
+                    file_path=Path(item["file"]),
+                    line_number=item.get("line", 1),
+                    message=f"Dead {item['type']}: {item['name']}",
+                    severity="warning",  # Dead code is typically a warning, not error
+                    issue_type=item["type"],
+                    name=item["name"],
+                    confidence=item.get("confidence", 0.0),
+                )
+                for item in data.get("dead_code", [])
+            ]
+
+            # Skylos success means no issues found
+            success = len(issues) == 0
+
+            return ToolResult(
+                success=success,
+                issues=issues,
+                raw_output=output,
+                tool_version=self.get_tool_version(),
+            )
+
+        except (KeyError, TypeError, ValueError) as e:
+            return self._create_error_result(
+                f"Failed to parse Skylos JSON output: {e}", raw_output=output
+            )
+
+    def _parse_text_output(self, output: str) -> ToolResult:
+        """Parse text output for human-readable display."""
+        issues: list[Issue] = []
+
+        if not output.strip():
+            # No output typically means no dead code found
+            return ToolResult(
+                success=True,
+                issues=[],
+                raw_output=output,
+                tool_version=self.get_tool_version(),
+            )
+
+        # Parse Skylos text output
+        # Expected format: "file.py:line: unused import 'name' (confidence: 86%)"
+        for line in output.strip().split("\\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            issue = self._parse_text_line(line)
+            if issue:
+                issues.append(issue)
+
+        # Success if no issues found
+        success = len(issues) == 0
+
+        return ToolResult(
+            success=success,
+            issues=issues,
+            raw_output=output,
+            tool_version=self.get_tool_version(),
+        )
+
+    def _parse_text_line(self, line: str) -> DeadCodeIssue | None:
+        """Parse a single line of Skylos text output."""
+        try:
+            basic_info = self._extract_basic_line_info(line)
+            if not basic_info:
+                return None
+
+            file_path, line_number, message_part = basic_info
+            issue_details = self._extract_issue_details(message_part)
+            confidence = self._extract_confidence(message_part)
+
+            return DeadCodeIssue(
+                file_path=file_path,
+                line_number=line_number,
+                message=f"Dead {issue_details['type']}: {issue_details['name']}",
+                severity="warning",
+                issue_type=issue_details["type"],
+                name=issue_details["name"],
+                confidence=confidence,
+            )
+
+        except (IndexError, ValueError):
+            return None
+
+    def _extract_basic_line_info(self, line: str) -> tuple[Path, int, str] | None:
+        """Extract file path, line number, and message from line."""
+        if ":" not in line:
+            return None
+
+        parts = line.split(":", 2)
+        if len(parts) < 3:
+            return None
+
+        file_path = Path(parts[0].strip())
+        try:
+            line_number = int(parts[1].strip())
+        except ValueError:
+            line_number = 1
+
+        message_part = parts[2].strip()
+        return file_path, line_number, message_part
+
+    def _extract_issue_details(self, message_part: str) -> dict[str, str]:
+        """Extract issue type and name from message."""
+        issue_type = "unknown"
+        name = "unknown"
+
+        lower_message = message_part.lower()
+
+        if "unused import" in lower_message:
+            issue_type = "import"
+            name = self._extract_name_from_quotes(message_part)
+        elif "unused function" in lower_message:
+            issue_type = "function"
+            name = self._extract_name_from_quotes(message_part)
+        elif "unused class" in lower_message:
+            issue_type = "class"
+            name = self._extract_name_from_quotes(message_part)
+
+        return {"type": issue_type, "name": name}
+
+    def _extract_name_from_quotes(self, message_part: str) -> str:
+        """Extract name from single quotes in message."""
+        quoted_parts = message_part.split("'")
+        if len(quoted_parts) >= 2:
+            return quoted_parts[1]
+        return "unknown"
+
+    def _extract_confidence(self, message_part: str) -> float:
+        """Extract confidence percentage from message."""
+        if "(confidence:" not in message_part:
+            return float(self.confidence_threshold)
+
+        try:
+            conf_part = message_part.split("(confidence:")[1].split(")")[0]
+            return float(conf_part.strip().replace("%", ""))
+        except (ValueError, IndexError):
+            return float(self.confidence_threshold)