crackerjack 0.30.3__py3-none-any.whl → 0.31.7__py3-none-any.whl

crackerjack/managers/test_progress.py

@@ -0,0 +1,114 @@
+"""Test progress tracking and display functionality.
+
+This module handles real-time test execution progress tracking, including collection
+and execution phases. Split from test_manager.py for better separation of concerns.
+"""
+
+import threading
+import time
+import typing as t
+
+
+class TestProgress:
+    """Tracks test execution progress with thread-safe updates."""
+
+    def __init__(self) -> None:
+        self.total_tests: int = 0
+        self.passed: int = 0
+        self.failed: int = 0
+        self.skipped: int = 0
+        self.errors: int = 0
+        self.current_test: str = ""
+        self.start_time: float = 0
+        self.is_complete: bool = False
+        self.is_collecting: bool = True
+        self.files_discovered: int = 0
+        self.collection_status: str = "Starting collection..."
+        self._lock = threading.Lock()
+        self._seen_files: set[str] = set()  # Track seen files to prevent duplicates
+
+    @property
+    def completed(self) -> int:
+        """Total completed tests (passed + failed + skipped + errors)."""
+        return self.passed + self.failed + self.skipped + self.errors
+
+    @property
+    def elapsed_time(self) -> float:
+        """Elapsed time since test start."""
+        return time.time() - self.start_time if self.start_time else 0
+
+    @property
+    def eta_seconds(self) -> float | None:
+        """Estimated time to completion based on current progress rate."""
+        if self.completed <= 0 or self.total_tests <= 0:
+            return None
+        progress_rate = (
+            self.completed / self.elapsed_time if self.elapsed_time > 0 else 0
+        )
+        remaining = self.total_tests - self.completed
+        return remaining / progress_rate if progress_rate > 0 else None
+
+    def update(self, **kwargs: t.Any) -> None:
+        """Thread-safe update of progress attributes."""
+        with self._lock:
+            for key, value in kwargs.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+
+    def format_progress(self) -> str:
+        """Format progress display for Rich output."""
+        if self.is_collecting:
+            return self._format_collection_progress()
+        return self._format_execution_progress()
+
+    def _format_collection_progress(self) -> str:
+        """Format test collection progress display."""
+        status_parts = [self.collection_status]
+
+        if self.files_discovered > 0:
+            status_parts.append(f"{self.files_discovered} test files")
+
+        elapsed = self.elapsed_time
+        if elapsed > 1:
+            status_parts.append(f"{elapsed:.1f}s")
+
+        return " | ".join(status_parts)
+
+    def _format_execution_progress(self) -> str:
+        """Format test execution progress display."""
+        parts = []
+
+        # Test progress
+        if self.total_tests > 0:
+            progress_pct = (self.completed / self.total_tests) * 100
+            parts.append(f"{self.completed}/{self.total_tests} ({progress_pct:.1f}%)")
+
+        # Status counts
+        status_parts = []
+        if self.passed > 0:
+            status_parts.append(f"✅ {self.passed}")
+        if self.failed > 0:
+            status_parts.append(f"❌ {self.failed}")
+        if self.skipped > 0:
+            status_parts.append(f"⏭ {self.skipped}")
+        if self.errors > 0:
+            status_parts.append(f"💥 {self.errors}")
+
+        if status_parts:
+            parts.append(" ".join(status_parts))
+
+        # Current test (truncated)
+        if self.current_test and not self.is_complete:
+            test_name = (
+                self.current_test[:30] + "..."
+                if len(self.current_test) > 30
+                else self.current_test
+            )
+            parts.append(f"Running: {test_name}")
+
+        # Timing
+        elapsed = self.elapsed_time
+        if elapsed > 1:
+            parts.append(f"{elapsed:.1f}s")
+
+        return " | ".join(parts)

crackerjack/mcp/cache.py

@@ -0,0 +1,336 @@
+import asyncio
+import json
+import time
+import typing as t
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+@dataclass
+class ErrorPattern:
+    pattern_id: str
+    error_type: str
+    error_code: str
+    message_pattern: str
+    file_pattern: str | None = None
+    common_fixes: list[str] | None = None
+    auto_fixable: bool = False
+    frequency: int = 1
+    last_seen: float | None = None
+
+    def __post_init__(self) -> None:
+        if self.common_fixes is None:
+            self.common_fixes = []
+        if self.last_seen is None:
+            self.last_seen = time.time()
+
+    def to_dict(self) -> dict[str, t.Any]:
+        return asdict(self)
+
+
+@dataclass
+class FixResult:
+    fix_id: str
+    pattern_id: str
+    success: bool
+    files_affected: list[str]
+    time_taken: float
+    error_message: str | None = None
+
+    def to_dict(self) -> dict[str, t.Any]:
+        return asdict(self)
+
+
+class ErrorCache:
+    def __init__(self, cache_dir: Path | None = None) -> None:
+        self._lock = asyncio.Lock()
+        self.cache_dir = cache_dir or Path.home() / ".cache" / "crackerjack-mcp"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.patterns_file = self.cache_dir / "error_patterns.json"
+        self.fixes_file = self.cache_dir / "fix_results.json"
+        self.patterns: dict[str, ErrorPattern] = {}
+        self.fix_results: list[FixResult] = []
+        self._load_cache()
+
+    async def add_pattern(self, pattern: ErrorPattern) -> None:
+        async with self._lock:
+            existing = self.patterns.get(pattern.pattern_id)
+            if existing:
+                self._update_existing_pattern(existing, pattern)
+            else:
+                self.patterns[pattern.pattern_id] = pattern
+            self._save_patterns()
+
+    def _update_existing_pattern(
+        self,
+        existing: ErrorPattern,
+        pattern: ErrorPattern,
+    ) -> None:
+        existing.frequency += 1
+        existing.last_seen = time.time()
+        if pattern.common_fixes:
+            self._merge_fixes(existing, pattern.common_fixes)
+
+    def _merge_fixes(self, existing: ErrorPattern, new_fixes: list[str]) -> None:
+        for fix in new_fixes:
+            if fix not in (existing.common_fixes or []):
+                if existing.common_fixes is None:
+                    existing.common_fixes = []
+                existing.common_fixes.append(fix)
+
+    def get_pattern(self, pattern_id: str) -> ErrorPattern | None:
+        return self.patterns.get(pattern_id)
+
+    def find_patterns_by_type(self, error_type: str) -> list[ErrorPattern]:
+        return [
+            pattern
+            for pattern in self.patterns.values()
+            if pattern.error_type == error_type
+        ]
+
+    def find_patterns_by_code(self, error_code: str) -> list[ErrorPattern]:
+        return [
+            pattern
+            for pattern in self.patterns.values()
+            if pattern.error_code == error_code
+        ]
+
+    def get_common_patterns(self, limit: int = 20) -> list[ErrorPattern]:
+        patterns = list(self.patterns.values())
+        patterns.sort(key=lambda p: p.frequency, reverse=True)
+        return patterns[:limit]
+
+    def get_auto_fixable_patterns(self) -> list[ErrorPattern]:
+        return [pattern for pattern in self.patterns.values() if pattern.auto_fixable]
+
+    async def add_fix_result(self, result: FixResult) -> None:
+        async with self._lock:
+            self.fix_results.append(result)
+            pattern = self.patterns.get(result.pattern_id)
+            if pattern and result.success:
+                pattern.auto_fixable = True
+                fix_command = f"Auto-fix applied for {result.pattern_id}"
+                if pattern.common_fixes is None:
+                    pattern.common_fixes = []
+                if fix_command not in pattern.common_fixes:
+                    pattern.common_fixes.append(fix_command)
+            self._save_fixes()
+        self._save_patterns()
+
+    def get_fix_success_rate(self, pattern_id: str) -> float:
+        pattern_fixes = [
+            result for result in self.fix_results if result.pattern_id == pattern_id
+        ]
+        if not pattern_fixes:
+            return 0.0
+        successful = sum(1 for result in pattern_fixes if result.success)
+        return successful / len(pattern_fixes)
+
+    def get_recent_patterns(self, hours: int = 24) -> list[ErrorPattern]:
+        cutoff_time = time.time() - (hours * 3600)
+
+        return [
+            pattern
+            for pattern in self.patterns.values()
+            if (pattern.last_seen or 0) >= cutoff_time
+        ]
+
+    def create_pattern_from_error(
+        self,
+        error_output: str,
+        error_type: str,
+    ) -> ErrorPattern | None:
+        try:
+            lines = error_output.split("\n")
+            for line in lines:
+                line = line.strip()
+                if not self._is_valid_error_line(line):
+                    continue
+                error_code, message_pattern = self._extract_error_info(line, error_type)
+                if self._is_meaningful_pattern(error_code, message_pattern):
+                    return self._create_error_pattern(
+                        error_type,
+                        error_code,
+                        message_pattern,
+                    )
+
+            return None
+        except Exception:
+            return None
+
+    def _is_valid_error_line(self, line: str) -> bool:
+        return bool(line and any(char.isalpha() for char in line))
+
+    def _extract_error_info(self, line: str, error_type: str) -> tuple[str, str]:
+        if error_type == "ruff":
+            return self._extract_ruff_info(line)
+        if error_type == "pyright":
+            return self._extract_pyright_info(line)
+        if error_type == "bandit":
+            return self._extract_bandit_info(line)
+        return "", line
+
+    def _extract_ruff_info(self, line: str) -> tuple[str, str]:
+        error_code = ""
+        message_pattern = line
+        if ": " in line and any(c.isdigit() for c in line):
+            parts = line.split(": ")
+            if len(parts) >= 4:
+                code_msg = parts[-1].strip()
+                if " " in code_msg:
+                    code_part, msg_part = code_msg.split(" ", 1)
+                    if code_part.isupper() or code_part[0].isupper():
+                        error_code = code_part
+                        message_pattern = msg_part
+
+        return error_code, message_pattern
+
+    def _extract_pyright_info(self, line: str) -> tuple[str, str]:
+        error_code = ""
+        message_pattern = line
+        if " - error: " in line:
+            parts = line.split(" - error: ")
+            if len(parts) >= 2:
+                message_pattern = parts[1].strip()
+                if "(" in message_pattern and ")" in message_pattern:
+                    error_code = message_pattern.split("(")[-1].split(")")[0]
+
+        return error_code, message_pattern
+
+    def _extract_bandit_info(self, line: str) -> tuple[str, str]:
+        error_code = ""
+        message_pattern = line
+        if "Issue: " in line:
+            message_pattern = line.split("Issue: ")[-1].strip()
+            if "Test: " in message_pattern:
+                parts = message_pattern.split("Test: ")
+                message_pattern = parts[0].strip()
+                error_code = parts[1].strip() if len(parts) > 1 else ""
+
+        return error_code, message_pattern
+
+    def _is_meaningful_pattern(self, error_code: str, message_pattern: str) -> bool:
+        return bool(error_code) or len(message_pattern) > 10
+
+    def _create_error_pattern(
+        self,
+        error_type: str,
+        error_code: str,
+        message_pattern: str,
+    ) -> ErrorPattern:
+        pattern_id = f"{error_type}_{error_code}_{hash(message_pattern) % 10000}"
+
+        return ErrorPattern(
+            pattern_id=pattern_id,
+            error_type=error_type,
+            error_code=error_code,
+            message_pattern=message_pattern,
+            auto_fixable=error_type == "ruff",
+        )
+
+    def analyze_output_for_patterns(
+        self,
+        output: str,
+        error_type: str,
+    ) -> list[ErrorPattern]:
+        patterns: list[ErrorPattern] = []
+        sections = output.split("\n\n")
+        for section in sections:
+            if section.strip():
+                pattern = self.create_pattern_from_error(section, error_type)
+                if pattern:
+                    self.add_pattern(pattern)
+                    patterns.append(pattern)
+
+        return patterns
+
+    def get_cache_stats(self) -> dict[str, t.Any]:
+        total_patterns = len(self.patterns)
+        auto_fixable = len(self.get_auto_fixable_patterns())
+        total_fixes = len(self.fix_results)
+        successful_fixes = sum(1 for result in self.fix_results if result.success)
+        frequencies = [pattern.frequency for pattern in self.patterns.values()]
+        avg_frequency = sum(frequencies) / len(frequencies) if frequencies else 0
+        type_counts = {}
+        for pattern in self.patterns.values():
+            type_counts[pattern.error_type] = type_counts.get(pattern.error_type, 0) + 1
+
+        return {
+            "total_patterns": total_patterns,
+            "auto_fixable_patterns": auto_fixable,
+            "auto_fixable_rate": (auto_fixable / total_patterns) * 100
+            if total_patterns
+            else 0,
+            "total_fix_attempts": total_fixes,
+            "successful_fixes": successful_fixes,
+            "fix_success_rate": (successful_fixes / total_fixes) * 100
+            if total_fixes
+            else 0,
+            "average_pattern_frequency": avg_frequency,
+            "error_types": type_counts,
+        }
+
+    def cleanup_old_patterns(self, days: int = 30) -> int:
+        cutoff_time = time.time() - (days * 24 * 3600)
+        old_patterns = [
+            pattern_id
+            for pattern_id, pattern in self.patterns.items()
+            if (pattern.last_seen or 0) < cutoff_time
+        ]
+        for pattern_id in old_patterns:
+            del self.patterns[pattern_id]
+        if old_patterns:
+            self._save_patterns()
+
+        return len(old_patterns)
+
+    def export_patterns(self, file_path: Path) -> None:
+        export_data = {
+            "export_time": time.time(),
+            "total_patterns": len(self.patterns),
+            "patterns": [pattern.to_dict() for pattern in self.patterns.values()],
+            "fix_results": [result.to_dict() for result in self.fix_results],
+            "stats": self.get_cache_stats(),
+        }
+        with file_path.open("w") as f:
+            json.dump(export_data, f, indent=2)
+
+    def _load_cache(self) -> None:
+        if self.patterns_file.exists():
+            try:
+                with self.patterns_file.open("r") as f:
+                    patterns_data = json.load(f)
+                self.patterns = {
+                    pid: ErrorPattern(**data) for pid, data in patterns_data.items()
+                }
+            except Exception:
+                self.patterns = {}
+        if self.fixes_file.exists():
+            try:
+                with self.fixes_file.open("r") as f:
+                    fixes_data = json.load(f)
+                self.fix_results = [FixResult(**data) for data in fixes_data]
+            except Exception:
+                self.fix_results = []
+
+    def _save_patterns(self) -> None:
+        try:
+            patterns_data = {
+                pid: pattern.to_dict() for pid, pattern in self.patterns.items()
+            }
+            with self.patterns_file.open("w") as f:
+                json.dump(patterns_data, f, indent=2)
+        except (OSError, json.JSONEncodeError):
+            pass
+        except Exception:
+            pass
+
+    def _save_fixes(self) -> None:
+        try:
+            fixes_data = [result.to_dict() for result in self.fix_results]
+            with self.fixes_file.open("w") as f:
+                json.dump(fixes_data, f, indent=2)
+        except (OSError, json.JSONEncodeError):
+            pass
+        except Exception:
+            pass

crackerjack/mcp/client_runner.py

@@ -0,0 +1,104 @@
+import asyncio
+import socket
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from mcp import stdio_client
+
+from .progress_monitor import (
+    run_crackerjack_with_enhanced_progress as run_crackerjack_with_progress,
+)
+
+
+def is_mcp_server_running(host: str = "localhost", port: int = 5173) -> bool:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        result = sock.connect_ex((host, port))
+        return result == 0
+    finally:
+        sock.close()
+
+
+async def ensure_mcp_server_running() -> subprocess.Popen | None:
+    console = Console()
+
+    if is_mcp_server_running():
+        console.print("[green]✅ MCP server already running[/green]")
+        return None
+
+    console.print("[yellow]🚀 Starting MCP server...[/yellow]")
+    server_process = subprocess.Popen(
+        [sys.executable, "-m", "crackerjack", "--start-mcp-server"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        start_new_session=True,
+    )
+
+    for _i in range(20):
+        if is_mcp_server_running():
+            console.print("[green]✅ MCP server started successfully[/green]")
+            return server_process
+        await asyncio.sleep(0.5)
+
+    console.print("[red]❌ Failed to start MCP server[/red]")
+    server_process.terminate()
+    msg = "Failed to start MCP server within timeout period"
+    raise RuntimeError(msg)
+
+
+async def run_with_mcp_server(command: str = "/crackerjack:run") -> None:
+    console = Console()
+
+    server_process = await ensure_mcp_server_running()
+
+    try:
+        server_script = Path(__file__).parent.parent / "__main__.py"
+        async with (
+            stdio_client(
+                sys.executable,
+                str(server_script),
+                "--start-mcp-server",
+            ) as (read_stream, write_stream),
+            read_stream.session(
+                read_stream=read_stream,
+                write_stream=write_stream,
+            ) as session,
+        ):
+            try:
+                await run_crackerjack_with_progress(session, command)
+            except Exception as e:
+                console.print(f"[bold red]Error: {e}[/bold red]")
+                sys.exit(1)
+    finally:
+        if server_process:
+            console.print(
+                "[yellow]Note: MCP server continues running in background[/yellow]",
+            )
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Run Crackerjack commands through MCP with progress monitoring",
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        default="/crackerjack:run",
+        help="Command to execute (default: /crackerjack:run)",
+    )
+    args = parser.parse_args()
+
+    try:
+        asyncio.run(run_with_mcp_server(args.command))
+    except KeyboardInterrupt:
+        Console().print("\n[yellow]Operation cancelled by user[/yellow]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()