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

crackerjack/mcp/websocket/jobs.py

@@ -0,0 +1,253 @@
+import asyncio
+import json
+import time
+import uuid
+from contextlib import suppress
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+console = Console()
+
+
+class JobManager:
+    def __init__(self, progress_dir: Path) -> None:
+        self.progress_dir = progress_dir
+        self.active_connections: dict[str, set[Any]] = {}
+        self.known_jobs: set[str] = set()
+        self.is_running = True
+
+        self.progress_dir.mkdir(exist_ok=True)
+
+    def validate_job_id(self, job_id: str) -> bool:
+        if not job_id:
+            return False
+
+        with suppress(ValueError):
+            uuid.UUID(job_id)
+            return True
+
+        import re
+
+        # Performance: Use simpler regex pattern without whitespace
+        return bool(re.match(r"^[a-zA-Z0-9_-]+$", job_id) and len(job_id) <= 50)
+
+    def add_connection(self, job_id: str, websocket: Any) -> None:
+        if job_id not in self.active_connections:
+            self.active_connections[job_id] = set()
+        self.active_connections[job_id].add(websocket)
+
+    def remove_connection(self, job_id: str, websocket: Any) -> None:
+        if job_id in self.active_connections:
+            self.active_connections[job_id].discard(websocket)
+            if not self.active_connections[job_id]:
+                del self.active_connections[job_id]
+
+    async def broadcast_to_job(self, job_id: str, data: dict) -> None:
+        if job_id not in self.active_connections:
+            return
+
+        connections = self.active_connections[job_id].copy()
+        for websocket in connections:
+            try:
+                await websocket.send_json(data)
+            except Exception:
+                self.remove_connection(job_id, websocket)
+
+    def get_latest_job_id(self) -> str | None:
+        if not self.progress_dir.exists():
+            return None
+
+        # Performance: Use more specific glob pattern to reduce filesystem calls
+        progress_files = list(self.progress_dir.glob("job-*.json"))
+        if not progress_files:
+            return None
+
+        latest_file = max(progress_files, key=lambda f: f.stat().st_mtime)
+        return self.extract_job_id_from_file(latest_file)
+
+    def extract_job_id_from_file(self, progress_file: Path) -> str | None:
+        # Performance: Use slice instead of replace for fixed prefix removal
+        return (
+            progress_file.stem[4:]  # Remove "job-" prefix (4 chars)
+            if progress_file.stem.startswith("job-")
+            else None
+        )
+
+    def get_job_progress(self, job_id: str) -> dict | None:
+        if not self.validate_job_id(job_id):
+            return None
+
+        progress_file = self.progress_dir / f"job-{job_id}.json"
+        if not progress_file.exists():
+            return None
+
+        try:
+            return json.loads(progress_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    async def _process_progress_file(self, progress_file: Path) -> None:
+        """Process a single progress file and handle new job detection."""
+        job_id = self.extract_job_id_from_file(progress_file)
+        if not (job_id and self.validate_job_id(job_id)):
+            return
+
+        progress_data = self.get_job_progress(job_id)
+        if progress_data and job_id not in self.known_jobs:
+            self.known_jobs.add(job_id)
+            console.print(f"[green]New job detected: {job_id}[/green]")
+            await self.broadcast_to_job(job_id, progress_data)
+
+    async def _monitor_directory_changes(self) -> None:
+        """Monitor the progress directory for new job files."""
+        while self.is_running:
+            try:
+                if self.progress_dir.exists():
+                    for progress_file in self.progress_dir.glob("job-*.json"):
+                        await self._process_progress_file(progress_file)
+
+                await asyncio.sleep(1)  # Check every second
+            except Exception as e:
+                console.print(f"[red]Progress monitoring error: {e}[/red]")
+                await asyncio.sleep(5)  # Wait longer on error
+
+    async def monitor_progress_files(self) -> None:
+        from crackerjack.mcp.file_monitor import create_progress_monitor
+
+        console.print("[blue]Starting progress file monitoring...[/blue]")
+
+        try:
+            monitor = create_progress_monitor(self.progress_dir)
+            await monitor.start()
+
+            def on_progress_update(job_id: str, progress_data: dict) -> None:
+                """Callback for when progress files are updated."""
+                if job_id and self.validate_job_id(job_id):
+                    # Schedule the broadcast in the event loop
+                    asyncio.create_task(self.broadcast_to_job(job_id, progress_data))
+
+                    if job_id not in self.known_jobs:
+                        self.known_jobs.add(job_id)
+                        console.print(f"[green]New job detected: {job_id}[/green]")
+
+            # Monitor for new job files by checking the directory periodically
+            await self._monitor_directory_changes()
+
+        except Exception as e:
+            console.print(f"[red]Progress monitoring setup error: {e}[/red]")
+
+    async def cleanup_old_jobs(self) -> None:
+        """Periodically clean up old job files."""
+        while self.is_running:
+            try:
+                await self._perform_cleanup_cycle()
+                await asyncio.sleep(3600)
+            except Exception as e:
+                console.print(f"[red]Cleanup error: {e}[/red]")
+                await asyncio.sleep(3600)
+
+    async def _perform_cleanup_cycle(self) -> None:
+        """Perform a single cleanup cycle for old jobs."""
+        if not self.progress_dir.exists():
+            return
+
+        cutoff_time = self._calculate_cleanup_cutoff_time()
+        old_job_files = self._find_old_job_files(cutoff_time)
+
+        for progress_file in old_job_files:
+            self._cleanup_old_job_file(progress_file)
+
+    def _calculate_cleanup_cutoff_time(self) -> float:
+        """Calculate cutoff time for job cleanup (24 hours ago)."""
+        return time.time() - (24 * 60 * 60)
+
+    def _find_old_job_files(self, cutoff_time: float) -> list[Path]:
+        """Find job files older than the cutoff time."""
+        return [
+            progress_file
+            for progress_file in self.progress_dir.glob("job-*.json")
+            if progress_file.stat().st_mtime < cutoff_time
+        ]
+
+    def _cleanup_old_job_file(self, progress_file: Path) -> None:
+        """Clean up a single old job file if it's safe to do so."""
+        job_id = self.extract_job_id_from_file(progress_file)
+
+        if job_id not in self.active_connections:
+            progress_file.unlink(missing_ok=True)
+            console.print(f"[yellow]Cleaned up old job: {job_id}[/yellow]")
+
+    async def timeout_stuck_jobs(self) -> None:
+        """Monitor and timeout stuck jobs that haven't been updated."""
+        while self.is_running:
+            try:
+                await self._check_and_timeout_stuck_jobs()
+                await asyncio.sleep(300)
+            except Exception as e:
+                console.print(f"[red]Timeout check error: {e}[/red]")
+                await asyncio.sleep(300)
+
+    async def _check_and_timeout_stuck_jobs(self) -> None:
+        """Check for stuck jobs and timeout those that are inactive."""
+        if not self.progress_dir.exists():
+            return
+
+        current_time = time.time()
+        timeout_seconds = 30 * 60
+
+        for progress_file in self.progress_dir.glob("job -* .json"):
+            await self._process_job_timeout_check(
+                progress_file,
+                current_time,
+                timeout_seconds,
+            )
+
+    async def _process_job_timeout_check(
+        self,
+        progress_file: Path,
+        current_time: float,
+        timeout_seconds: int,
+    ) -> None:
+        """Process timeout check for a single job file."""
+        try:
+            progress_data = json.loads(progress_file.read_text())
+
+            if self._should_timeout_job(
+                progress_data,
+                progress_file,
+                current_time,
+                timeout_seconds,
+            ):
+                self._timeout_job(progress_data, progress_file)
+
+        except (json.JSONDecodeError, OSError):
+            pass  # Skip files that can't be processed
+
+    def _should_timeout_job(
+        self,
+        progress_data: dict,
+        progress_file: Path,
+        current_time: float,
+        timeout_seconds: int,
+    ) -> bool:
+        """Determine if a job should be timed out."""
+        return (
+            progress_data.get("status") == "running"
+            and current_time - progress_file.stat().st_mtime > timeout_seconds
+        )
+
+    def _timeout_job(self, progress_data: dict, progress_file: Path) -> None:
+        """Mark a job as failed due to timeout."""
+        progress_data["status"] = "failed"
+        progress_data["message"] = "Job timed out (no updates for 30 minutes)"
+
+        progress_file.write_text(json.dumps(progress_data, indent=2))
+
+        job_id = progress_data.get("job_id", "unknown")
+        console.print(f"[red]Job {job_id} timed out and marked as failed[/red]")
+
+    def cleanup(self) -> None:
+        self.is_running = False
+        console.print("[blue]Job manager cleanup completed[/blue]")

crackerjack/mcp/websocket/server.py

@@ -0,0 +1,116 @@
+import signal
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+import uvicorn
+from rich.console import Console
+
+from .app import create_websocket_app
+from .jobs import JobManager
+
+console = Console()
+
+
+class WebSocketServer:
+    def __init__(self, port: int = 8675) -> None:
+        self.port = port
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
+        self.is_running = True
+        self.job_manager: JobManager | None = None
+        self.app = None
+
+    def setup(self) -> None:
+        self.progress_dir.mkdir(exist_ok=True)
+
+        self.job_manager = JobManager(self.progress_dir)
+
+        self.app = create_websocket_app(self.job_manager, self.progress_dir)
+
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    def _signal_handler(self, _signum: int, _frame) -> None:
+        console.print("\n[yellow]Shutting down WebSocket server...[/yellow]")
+        self.is_running = False
+
+    def run(self) -> None:
+        try:
+            self.setup()
+            console.print(
+                f"[green]Starting WebSocket server on port {self.port}[/green]",
+            )
+            console.print(f"Progress directory: {self.progress_dir}")
+            console.print("Press Ctrl + C to stop")
+
+            config = uvicorn.Config(
+                app=self.app,
+                port=self.port,
+                host="127.0.0.1",
+                log_level="info",
+            )
+
+            server = uvicorn.Server(config)
+            server.run()
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Server stopped by user[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Server error: {e}[/red]")
+        finally:
+            pass  # Cleanup handled by FastAPI lifespan
+
+
+def handle_websocket_server_command(
+    start: bool = False,
+    stop: bool = False,
+    restart: bool = False,
+    port: int = 8675,
+) -> None:
+    """Handle WebSocket server start/stop/restart commands."""
+    if stop or restart:
+        console.print("[yellow]Stopping WebSocket servers...[/yellow]")
+        # Kill any existing uvicorn processes running on the port
+        try:
+            result = subprocess.run(
+                ["pkill", "-f", f"uvicorn.*:{port}"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                console.print("[green]✅ WebSocket servers stopped[/green]")
+            else:
+                console.print("[dim]No WebSocket servers were running[/dim]")
+        except subprocess.TimeoutExpired:
+            console.print("[red]Timeout stopping WebSocket servers[/red]")
+        except Exception as e:
+            console.print(f"[red]Error stopping WebSocket servers: {e}[/red]")
+
+        if stop:
+            return
+
+        # For restart, wait a moment before starting again
+        time.sleep(2)
+
+    if start or restart:
+        console.print(f"[green]Starting WebSocket server on port {port}...[/green]")
+        try:
+            server = WebSocketServer(port)
+            server.run()
+        except Exception as e:
+            console.print(f"[red]Failed to start WebSocket server: {e}[/red]")
+
+
+def main(port: int = 8675) -> None:
+    server = WebSocketServer(port)
+    server.run()
+
+
+if __name__ == "__main__":
+    import sys
+
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8675
+    main(port)

crackerjack/mcp/websocket/websocket_handler.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from rich.console import Console
+
+from .jobs import JobManager
+
+console = Console()
+
+
+class WebSocketHandler:
+    def __init__(self, job_manager: JobManager, progress_dir: Path) -> None:
+        self.job_manager = job_manager
+        self.progress_dir = progress_dir
+
+    async def handle_connection(self, websocket: WebSocket, job_id: str) -> None:
+        if not self.job_manager.validate_job_id(job_id):
+            await websocket.close(code=1008, reason="Invalid job ID")
+            return
+
+        await websocket.accept()
+        self.job_manager.add_connection(job_id, websocket)
+
+        console.print(f"[green]WebSocket connected for job: {job_id}[/green]")
+
+        try:
+            initial_progress = self.job_manager.get_job_progress(job_id)
+            if initial_progress:
+                await websocket.send_json(initial_progress)
+            else:
+                await websocket.send_json(
+                    {
+                        "job_id": job_id,
+                        "status": "waiting",
+                        "message": "Waiting for job to start...",
+                        "overall_progress": 0,
+                        "iteration": 0,
+                        "max_iterations": 10,
+                        "current_stage": "Initializing",
+                    },
+                )
+
+            while True:
+                try:
+                    data = await websocket.receive_text()
+                    console.print(
+                        f"[blue]Received message for {job_id}: {data[:100]}...[/blue]",
+                    )
+
+                    await websocket.send_json(
+                        {
+                            "type": "echo",
+                            "message": f"Received: {data}",
+                            "job_id": job_id,
+                        },
+                    )
+
+                except WebSocketDisconnect:
+                    break
+
+        except WebSocketDisconnect:
+            console.print(f"[yellow]WebSocket disconnected for job: {job_id}[/yellow]")
+        except Exception as e:
+            console.print(f"[red]WebSocket error for job {job_id}: {e}[/red]")
+        finally:
+            self.job_manager.remove_connection(job_id, websocket)
+
+
+def register_websocket_routes(
+    app: FastAPI,
+    job_manager: JobManager,
+    progress_dir: Path,
+) -> None:
+    handler = WebSocketHandler(job_manager, progress_dir)
+
+    @app.websocket(" / ws / progress / {job_id}")
+    async def websocket_progress_endpoint(websocket: WebSocket, job_id: str) -> None:
+        await handler.handle_connection(websocket, job_id)

crackerjack/mcp/websocket_server.py

@@ -0,0 +1,10 @@
+from .websocket import WebSocketServer, main
+
+__all__ = ["WebSocketServer", "main"]
+
+
+if __name__ == "__main__":
+    import sys
+
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8675
+    main(port)

crackerjack/models/__init__.py

@@ -0,0 +1,31 @@
+from .config import (
+    AIConfig,
+    CleaningConfig,
+    CleanupConfig,
+    ExecutionConfig,
+    GitConfig,
+    HookConfig,
+    ProgressConfig,
+    PublishConfig,
+    TestConfig,
+    WorkflowOptions,
+)
+from .protocols import OptionsProtocol
+from .task import HookResult, SessionTracker, TaskStatus
+
+__all__ = [
+    "AIConfig",
+    "CleaningConfig",
+    "CleanupConfig",
+    "ExecutionConfig",
+    "GitConfig",
+    "HookConfig",
+    "HookResult",
+    "OptionsProtocol",
+    "ProgressConfig",
+    "PublishConfig",
+    "SessionTracker",
+    "TaskStatus",
+    "TestConfig",
+    "WorkflowOptions",
+]

crackerjack/models/config.py

@@ -0,0 +1,93 @@
+import typing as t
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CleaningConfig:
+    clean: bool = True
+    update_docs: bool = False
+    force_update_docs: bool = False
+    compress_docs: bool = False
+    auto_compress_docs: bool = False
+
+
+@dataclass
+class HookConfig:
+    skip_hooks: bool = False
+    update_precommit: bool = False
+    experimental_hooks: bool = False
+    enable_pyrefly: bool = False
+    enable_ty: bool = False
+
+
+@dataclass
+class TestConfig:
+    test: bool = False
+    benchmark: bool = False
+    test_workers: int = 0
+    test_timeout: int = 0
+
+
+@dataclass
+class PublishConfig:
+    publish: t.Any | None = None
+    bump: t.Any | None = None
+    all: t.Any | None = None
+    no_git_tags: bool = False
+    skip_version_check: bool = False
+
+
+@dataclass
+class GitConfig:
+    commit: bool = False
+    create_pr: bool = False
+
+
+@dataclass
+class AIConfig:
+    ai_agent: bool = False
+    start_mcp_server: bool = False
+    max_iterations: int = 10
+    autofix: bool = True
+    ai_agent_autofix: bool = False
+
+
+@dataclass
+class ExecutionConfig:
+    interactive: bool = False
+    verbose: bool = False
+    async_mode: bool = False
+    no_config_updates: bool = False
+
+
+@dataclass
+class ProgressConfig:
+    enabled: bool = False
+
+
+@dataclass
+class CleanupConfig:
+    auto_cleanup: bool = True
+    keep_debug_logs: int = 5
+    keep_coverage_files: int = 10
+
+
+@dataclass
+class EnterpriseConfig:
+    enabled: bool = False
+    license_key: str | None = None
+    organization: str | None = None
+
+
+@dataclass
+class WorkflowOptions:
+    cleaning: CleaningConfig = field(default_factory=CleaningConfig)
+    hooks: HookConfig = field(default_factory=HookConfig)
+    testing: TestConfig = field(default_factory=TestConfig)
+    publishing: PublishConfig = field(default_factory=PublishConfig)
+    git: GitConfig = field(default_factory=GitConfig)
+    ai: AIConfig = field(default_factory=AIConfig)
+    execution: ExecutionConfig = field(default_factory=ExecutionConfig)
+    progress: ProgressConfig = field(default_factory=ProgressConfig)
+    cleanup: CleanupConfig = field(default_factory=CleanupConfig)
+    enterprise: EnterpriseConfig = field(default_factory=EnterpriseConfig)