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

crackerjack/managers/test_progress.py

@@ -8,9 +8,6 @@ import threading
 import time
 import typing as t
 
-from rich.align import Align
-from rich.table import Table
-
 
 class TestProgress:
     """Tracks test execution progress with thread-safe updates."""
@@ -58,87 +55,60 @@ class TestProgress:
                 if hasattr(self, key):
                     setattr(self, key, value)
 
-    def format_progress(self) -> Align:
+    def format_progress(self) -> str:
         """Format progress display for Rich output."""
         if self.is_collecting:
-            return Align.center(self._format_collection_progress())
-        return Align.center(self._format_execution_progress())
+            return self._format_collection_progress()
+        return self._format_execution_progress()
 
-    def _format_collection_progress(self) -> Table:
+    def _format_collection_progress(self) -> str:
         """Format test collection progress display."""
-        table = Table.grid(padding=(0, 2))
-        table.add_column()
-        table.add_column(justify="center")
-
-        # Collection status
-        table.add_row(
-            "[yellow]📋[/yellow] Test Collection",
-            f"[dim]{self.collection_status}[/dim]",
-        )
+        status_parts = [self.collection_status]
 
-        # Files discovered
         if self.files_discovered > 0:
-            table.add_row(
-                "[cyan]📁[/cyan] Files Found",
-                f"[green]{self.files_discovered}[/green] test files",
-            )
+            status_parts.append(f"{self.files_discovered} test files")
 
-        # Elapsed time
         elapsed = self.elapsed_time
         if elapsed > 1:
-            table.add_row("[blue]⏱️[/blue] Elapsed", f"[dim]{elapsed:.1f}s[/dim]")
+            status_parts.append(f"{elapsed:.1f}s")
 
-        return table
+        return " | ".join(status_parts)
 
-    def _format_execution_progress(self) -> Table:
+    def _format_execution_progress(self) -> str:
         """Format test execution progress display."""
-        table = Table.grid(padding=(0, 2))
-        table.add_column()
-        table.add_column(justify="center")
+        parts = []
 
-        # Progress bar representation
+        # Test progress
         if self.total_tests > 0:
             progress_pct = (self.completed / self.total_tests) * 100
-            completed_blocks = int((self.completed / self.total_tests) * 20)
-            remaining_blocks = 20 - completed_blocks
-            progress_bar = "█" * completed_blocks + "░" * remaining_blocks
-
-            table.add_row(
-                "[yellow]⚡[/yellow] Progress",
-                f"[green]{progress_bar}[/green] {progress_pct:.1f}%",
-            )
-
-        # Test counts
-        table.add_row("[green]✅[/green] Passed", f"[green]{self.passed}[/green]")
+            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:
-            table.add_row("[red]❌[/red] Failed", f"[red]{self.failed}[/red]")
-
+            status_parts.append(f"❌ {self.failed}")
         if self.skipped > 0:
-            table.add_row(
-                "[yellow]⏭️[/yellow] Skipped", f"[yellow]{self.skipped}[/yellow]"
-            )
-
+            status_parts.append(f"⏭ {self.skipped}")
         if self.errors > 0:
-            table.add_row("[red]💥[/red] Errors", f"[red]{self.errors}[/red]")
+            status_parts.append(f"💥 {self.errors}")
 
-        # Current test
+        if status_parts:
+            parts.append(" ".join(status_parts))
+
+        # Current test (truncated)
         if self.current_test and not self.is_complete:
-            table.add_row(
-                "[blue]🔄[/blue] Running",
-                f"[dim]{self.current_test[:50]}...[/dim]"
-                if len(self.current_test) > 50
-                else f"[dim]{self.current_test}[/dim]",
+            test_name = (
+                self.current_test[:30] + "..."
+                if len(self.current_test) > 30
+                else self.current_test
             )
+            parts.append(f"Running: {test_name}")
 
-        # Timing information
+        # Timing
         elapsed = self.elapsed_time
         if elapsed > 1:
-            table.add_row("[blue]⏱️[/blue] Elapsed", f"[dim]{elapsed:.1f}s[/dim]")
-
-        # ETA
-        eta = self.eta_seconds
-        if eta and eta > 1 and not self.is_complete:
-            table.add_row("[blue]📅[/blue] ETA", f"[dim]{eta:.1f}s[/dim]")
+            parts.append(f"{elapsed:.1f}s")
 
-        return table
+        return " | ".join(parts)

crackerjack/mcp/context.py

@@ -521,6 +521,12 @@ class MCPServerContext:
     ) -> None:
         await self.batched_saver.schedule_save(save_id, save_func)
 
+    def get_current_time(self) -> str:
+        """Get current timestamp as string for progress tracking."""
+        import datetime
+
+        return datetime.datetime.now().isoformat()
+
     def get_context_stats(self) -> dict[str, t.Any]:
         return {
             "initialized": self._initialized,

crackerjack/mcp/tools/execution_tools.py

@@ -140,12 +140,14 @@ async def _validate_context_and_rate_limit(context: t.Any) -> str | None:
         from contextlib import suppress
 
         with suppress(Exception):
-            allowed = await context.rate_limiter.acquire("execute_crackerjack")
+            allowed, details = await context.rate_limiter.check_request_allowed(
+                "execute_crackerjack"
+            )
             if not allowed:
                 return json.dumps(
                     {
                         "status": "error",
-                        "message": "Rate limit exceeded. Please wait before retrying.",
+                        "message": f"Rate limit exceeded: {details}. Please wait before retrying.",
                     }
                 )
 

crackerjack/mcp/tools/progress_tools.py

@@ -25,9 +25,78 @@ def _create_progress_file(job_id: str) -> Path:
     return progress_dir / f"job-{job_id}.json"
 
 
+def _clamp_progress(value: int) -> int:
+    return min(100, max(0, value))
+
+
+def _get_timestamp() -> str:
+    context = get_context()
+    return context.get_current_time() if context else ""
+
+
+def _build_dict_format_progress(
+    job_id: str,
+    progress_data: dict[str, t.Any],
+    iteration: int,
+    max_iterations: int,
+    overall_progress: int,
+    current_stage: str,
+    stage_progress: int,
+    message: str,
+) -> dict[str, t.Any]:
+    return {
+        "job_id": job_id,
+        "status": progress_data.get("status", "running"),
+        "iteration": progress_data.get("iteration", iteration),
+        "max_iterations": progress_data.get("max_iterations", max_iterations),
+        "overall_progress": _clamp_progress(
+            progress_data.get("overall_progress", overall_progress)
+        ),
+        "current_stage": progress_data.get("type", current_stage),
+        "stage_progress": _clamp_progress(
+            progress_data.get("stage_progress", stage_progress)
+        ),
+        "message": progress_data.get("message", message),
+        "timestamp": _get_timestamp(),
+    }
+
+
+def _build_legacy_format_progress(
+    job_id: str,
+    progress_data: str | None,
+    iteration: int,
+    max_iterations: int,
+    overall_progress: int,
+    current_stage: str,
+    stage_progress: int,
+    message: str,
+) -> dict[str, t.Any]:
+    status = progress_data if isinstance(progress_data, str) else "running"
+    return {
+        "job_id": job_id,
+        "status": status,
+        "iteration": iteration,
+        "max_iterations": max_iterations,
+        "overall_progress": _clamp_progress(overall_progress),
+        "current_stage": current_stage,
+        "stage_progress": _clamp_progress(stage_progress),
+        "message": message,
+        "timestamp": _get_timestamp(),
+    }
+
+
+def _notify_websocket(final_progress_data: dict[str, t.Any]) -> None:
+    context = get_context()
+    if context and hasattr(context, "websocket_progress_queue"):
+        with contextlib.suppress(Exception):
+            context.websocket_progress_queue.put_nowait(final_progress_data)
+
+
 def _update_progress(
     job_id: str,
-    status: str = "running",
+    progress_data: dict[str, t.Any] | str = None,
+    context: t.Any = None,
+    # Legacy parameters for backward compatibility
     iteration: int = 1,
     max_iterations: int = 10,
     overall_progress: int = 0,
@@ -38,24 +107,31 @@ def _update_progress(
     try:
         progress_file = _create_progress_file(job_id)
 
-        progress_data = {
-            "job_id": job_id,
-            "status": status,
-            "iteration": iteration,
-            "max_iterations": max_iterations,
-            "overall_progress": min(100, max(0, overall_progress)),
-            "current_stage": current_stage,
-            "stage_progress": min(100, max(0, stage_progress)),
-            "message": message,
-            "timestamp": get_context().get_current_time() if get_context() else "",
-        }
-
-        progress_file.write_text(json.dumps(progress_data, indent=2))
-
-        context = get_context()
-        if context and hasattr(context, "websocket_progress_queue"):
-            with contextlib.suppress(Exception):
-                context.websocket_progress_queue.put_nowait(progress_data)
+        if isinstance(progress_data, dict):
+            final_progress_data = _build_dict_format_progress(
+                job_id,
+                progress_data,
+                iteration,
+                max_iterations,
+                overall_progress,
+                current_stage,
+                stage_progress,
+                message,
+            )
+        else:
+            final_progress_data = _build_legacy_format_progress(
+                job_id,
+                progress_data,
+                iteration,
+                max_iterations,
+                overall_progress,
+                current_stage,
+                stage_progress,
+                message,
+            )
+
+        progress_file.write_text(json.dumps(final_progress_data, indent=2))
+        _notify_websocket(final_progress_data)
 
     except Exception as e:
         context = get_context()

crackerjack/mcp/tools/workflow_executor.py

@@ -24,10 +24,15 @@ async def execute_crackerjack_workflow(
     try:
         return await _execute_crackerjack_sync(job_id, args, kwargs, get_context())
     except Exception as e:
+        # Add full traceback for debugging
+        import traceback
+
+        error_details = traceback.format_exc()
         return {
             "job_id": job_id,
             "status": "failed",
             "error": f"Execution failed: {e}",
+            "traceback": error_details,
             "timestamp": time.time(),
         }
 
@@ -64,7 +69,7 @@ async def _initialize_execution(
     context: t.Any,
 ) -> dict[str, t.Any]:
     """Initialize execution environment and validate parameters."""
-    await _update_progress(
+    _update_progress(
         job_id,
         {
             "type": "initialization",
@@ -86,7 +91,7 @@ async def _initialize_execution(
             "job_id": job_id,
         }
 
-    await _update_progress(
+    _update_progress(
         job_id,
         {
             "type": "initialization",
@@ -111,7 +116,7 @@ async def _setup_orchestrator(
     context: t.Any,
 ) -> dict[str, t.Any]:
     """Set up the appropriate orchestrator based on configuration."""
-    await _update_progress(
+    _update_progress(
         job_id,
         {
             "type": "setup",
@@ -121,7 +126,9 @@ async def _setup_orchestrator(
         context,
     )
 
-    use_advanced = kwargs.get("advanced_orchestration", True)
+    use_advanced = kwargs.get(
+        "advanced_orchestration", False
+    )  # Temporarily disable advanced orchestration
 
     try:
         if use_advanced:
@@ -161,7 +168,6 @@ async def _create_advanced_orchestrator(
 
     orchestrator = AsyncWorkflowOrchestrator(
         pkg_path=Path(working_dir),
-        container=container,
     )
 
     return orchestrator
@@ -233,7 +239,7 @@ async def _run_workflow_iterations(
     max_iterations = kwargs.get("max_iterations", 10)
 
     for iteration in range(max_iterations):
-        await _update_progress(
+        _update_progress(
             job_id,
             {
                 "type": "iteration",
@@ -250,7 +256,15 @@ async def _run_workflow_iterations(
             )
 
             if success:
-                return _create_success_result(job_id, iteration + 1, context)
+                # Attempt coverage improvement after successful execution (if enabled)
+                coverage_result = None
+                if kwargs.get("boost_coverage", False):  # Temporarily disabled
+                    coverage_result = await _attempt_coverage_improvement(
+                        job_id, orchestrator, context
+                    )
+                return _create_success_result(
+                    job_id, iteration + 1, context, coverage_result
+                )
 
             # Handle retry logic
             if iteration < max_iterations - 1:
@@ -266,14 +280,54 @@ def _create_workflow_options(kwargs: dict[str, t.Any]) -> t.Any:
     """Create workflow options from kwargs."""
     from types import SimpleNamespace
 
-    # Create options object with default values
+    # Create options object with all required attributes from OptionsProtocol
     options = SimpleNamespace()
-    options.test_mode = kwargs.get("test_mode", True)
-    options.ai_agent = kwargs.get("ai_agent", True)
+
+    # Core execution options
+    options.commit = kwargs.get("commit", False)
     options.interactive = kwargs.get("interactive", False)
+    options.no_config_updates = kwargs.get("no_config_updates", False)
+    options.verbose = kwargs.get("verbose", True)
+    options.clean = kwargs.get("clean", False)
+    options.test = kwargs.get("test_mode", True)
     options.benchmark = kwargs.get("benchmark", False)
     options.skip_hooks = kwargs.get("skip_hooks", False)
-    options.verbose = kwargs.get("verbose", True)
+    options.ai_agent = kwargs.get("ai_agent", True)
+    options.async_mode = kwargs.get("async_mode", True)
+
+    # Test options
+    options.test_workers = kwargs.get("test_workers", 0)
+    options.test_timeout = kwargs.get("test_timeout", 0)
+
+    # Publishing options
+    options.publish = kwargs.get("publish")
+    options.bump = kwargs.get("bump")
+    options.all = kwargs.get("all")
+    options.create_pr = kwargs.get("create_pr", False)
+    options.no_git_tags = kwargs.get("no_git_tags", False)
+    options.skip_version_check = kwargs.get("skip_version_check", False)
+    options.cleanup_pypi = kwargs.get("cleanup_pypi", False)
+    options.keep_releases = kwargs.get("keep_releases", 10)
+
+    # Server options
+    options.start_mcp_server = kwargs.get("start_mcp_server", False)
+
+    # Hook options
+    options.update_precommit = kwargs.get("update_precommit", False)
+    options.experimental_hooks = kwargs.get("experimental_hooks", False)
+    options.enable_pyrefly = kwargs.get("enable_pyrefly", False)
+    options.enable_ty = kwargs.get("enable_ty", False)
+
+    # Cleanup options
+    options.cleanup = kwargs.get("cleanup")
+
+    # Coverage and progress
+    options.coverage = kwargs.get("coverage", False)
+    options.track_progress = kwargs.get("track_progress", False)
+
+    # Speed options
+    options.fast = kwargs.get("fast", False)
+    options.comp = kwargs.get("comp", False)
 
     return options
 
@@ -286,17 +340,52 @@ async def _execute_single_iteration(
     context: t.Any,
 ) -> bool:
     """Execute a single workflow iteration."""
-    if hasattr(orchestrator, "execute_workflow"):
-        return await orchestrator.execute_workflow(options)
-    # Fallback for synchronous orchestrators
-    return orchestrator.run(options)
+    try:
+        # Check for orchestrator workflow methods
+        if hasattr(orchestrator, "run_complete_workflow"):
+            # Standard WorkflowOrchestrator method is async
+            result = orchestrator.run_complete_workflow(options)
+            if result is None:
+                raise ValueError(
+                    "Method run_complete_workflow returned None instead of awaitable"
+                )
+            return await result
+        elif hasattr(orchestrator, "run_complete_workflow_async"):
+            result = orchestrator.run_complete_workflow_async(options)
+            if result is None:
+                raise ValueError(
+                    "Method run_complete_workflow_async returned None instead of awaitable"
+                )
+            return await result
+        elif hasattr(orchestrator, "execute_workflow"):
+            result = orchestrator.execute_workflow(options)
+            if result is None:
+                raise ValueError(
+                    "Method execute_workflow returned None instead of awaitable"
+                )
+            return await result
+        elif hasattr(orchestrator, "run"):
+            # Fallback for synchronous orchestrators
+            return orchestrator.run(options)
+        else:
+            raise ValueError(
+                f"Orchestrator {type(orchestrator)} has no recognized workflow execution method"
+            )
+    except Exception as e:
+        # Add detailed error info for debugging
+        raise RuntimeError(
+            f"Error in _execute_single_iteration (iteration {iteration}): {e}"
+        ) from e
 
 
 def _create_success_result(
-    job_id: str, iterations: int, context: t.Any
+    job_id: str,
+    iterations: int,
+    context: t.Any,
+    coverage_result: dict[str, t.Any] | None = None,
 ) -> dict[str, t.Any]:
     """Create success result with completion data."""
-    return {
+    result = {
         "job_id": job_id,
         "status": "completed",
         "iterations": iterations,
@@ -305,10 +394,15 @@ def _create_success_result(
         "success": True,
     }
 
+    if coverage_result:
+        result["coverage_improvement"] = coverage_result
+
+    return result
+
 
 async def _handle_iteration_retry(job_id: str, iteration: int, context: t.Any) -> None:
     """Handle retry logic between iterations."""
-    await _update_progress(
+    _update_progress(
         job_id,
         {
             "type": "iteration",
@@ -327,7 +421,7 @@ async def _handle_iteration_error(
     job_id: str, iteration: int, error: Exception, context: t.Any
 ) -> dict[str, t.Any]:
     """Handle errors during iteration execution."""
-    await _update_progress(
+    _update_progress(
         job_id,
         {
             "type": "error",
@@ -347,6 +441,117 @@ async def _handle_iteration_error(
     }
 
 
+async def _attempt_coverage_improvement(
+    job_id: str, orchestrator: t.Any, context: t.Any
+) -> dict[str, t.Any]:
+    """Attempt proactive coverage improvement after successful workflow execution."""
+    try:
+        _update_progress(
+            job_id,
+            {
+                "type": "coverage_improvement",
+                "status": "starting",
+                "message": "Analyzing coverage for improvement opportunities...",
+            },
+            context,
+        )
+
+        # Get project path from orchestrator
+        project_path = getattr(orchestrator, "pkg_path", None)
+        if not project_path:
+            return {"status": "skipped", "reason": "No project path available"}
+
+        # Import coverage improvement orchestrator
+        from crackerjack.orchestration.coverage_improvement import (
+            create_coverage_improvement_orchestrator,
+        )
+
+        # Create coverage orchestrator
+        coverage_orchestrator = await create_coverage_improvement_orchestrator(
+            project_path,
+            console=getattr(orchestrator, "console", None),
+        )
+
+        # Check if improvement is needed
+        should_improve = await coverage_orchestrator.should_improve_coverage()
+        if not should_improve:
+            _update_progress(
+                job_id,
+                {
+                    "type": "coverage_improvement",
+                    "status": "skipped",
+                    "message": "Coverage improvement not needed (already at 100%)",
+                },
+                context,
+            )
+            return {"status": "skipped", "reason": "Coverage at 100%"}
+
+        # Create agent context (simplified)
+        from crackerjack.agents.base import AgentContext
+
+        agent_context = AgentContext(project_path=project_path, console=None)
+
+        # Execute coverage improvement
+        _update_progress(
+            job_id,
+            {
+                "type": "coverage_improvement",
+                "status": "executing",
+                "message": "Generating tests to improve coverage...",
+            },
+            context,
+        )
+
+        improvement_result = await coverage_orchestrator.execute_coverage_improvement(
+            agent_context
+        )
+
+        # Update progress with results
+        if improvement_result["status"] == "completed":
+            _update_progress(
+                job_id,
+                {
+                    "type": "coverage_improvement",
+                    "status": "completed",
+                    "message": f"Coverage improvement: {len(improvement_result.get('fixes_applied', []))} tests created",
+                    "fixes_applied": improvement_result.get("fixes_applied", []),
+                    "files_modified": improvement_result.get("files_modified", []),
+                },
+                context,
+            )
+        else:
+            _update_progress(
+                job_id,
+                {
+                    "type": "coverage_improvement",
+                    "status": "completed_with_issues",
+                    "message": f"Coverage improvement attempted: {improvement_result.get('status', 'unknown')}",
+                },
+                context,
+            )
+
+        return improvement_result
+
+    except Exception as e:
+        _update_progress(
+            job_id,
+            {
+                "type": "coverage_improvement",
+                "status": "failed",
+                "error": str(e),
+                "message": f"Coverage improvement failed: {e}",
+            },
+            context,
+        )
+
+        return {
+            "status": "failed",
+            "error": str(e),
+            "fixes_applied": [],
+            "files_modified": [],
+        }
+
+
 def _create_failure_result(
     job_id: str, max_iterations: int, context: t.Any
 ) -> dict[str, t.Any]: