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

crackerjack/mcp/tools/utility_tools.py

@@ -0,0 +1,341 @@
+import json
+import time
+import typing as t
+from contextlib import suppress
+from pathlib import Path
+
+from crackerjack.mcp.context import get_context
+
+
+def _create_error_response(message: str, success: bool = False) -> str:
+    """Utility function to create standardized error responses."""
+    return json.dumps({"error": message, "success": success}, indent=2)
+
+
+def register_utility_tools(mcp_app: t.Any) -> None:
+    """Register utility slash command tools."""
+    _register_clean_tool(mcp_app)
+    _register_config_tool(mcp_app)
+    _register_analyze_tool(mcp_app)
+
+
+def _clean_file_if_old(
+    file_path: Path, cutoff_time: float, dry_run: bool, file_type: str
+) -> dict | None:
+    """Clean a single file if it's older than cutoff time."""
+    with suppress(OSError):
+        if file_path.stat().st_mtime < cutoff_time:
+            file_size = file_path.stat().st_size
+            if not dry_run:
+                file_path.unlink()
+            return {"path": str(file_path), "size": file_size, "type": file_type}
+    return None
+
+
+def _clean_temp_files(cutoff_time: float, dry_run: bool) -> tuple[list[dict], int]:
+    """Clean temporary files older than cutoff time."""
+    import tempfile
+
+    cleaned_files = []
+    total_size = 0
+    temp_dir = Path(tempfile.gettempdir())
+
+    patterns = ("crackerjack-*.log", "crackerjack-task-error-*.log", ".coverage.*")
+    for pattern in patterns:
+        for file_path in temp_dir.glob(pattern):
+            file_info = _clean_file_if_old(file_path, cutoff_time, dry_run, "temp")
+            if file_info:
+                cleaned_files.append(file_info)
+                total_size += file_info["size"]
+
+    return cleaned_files, total_size
+
+
+def _clean_progress_files(
+    context: t.Any, cutoff_time: float, dry_run: bool
+) -> tuple[list[dict], int]:
+    """Clean progress files older than cutoff time."""
+    cleaned_files = []
+    total_size = 0
+
+    if context.progress_dir.exists():
+        for progress_file in context.progress_dir.glob("*.json"):
+            file_info = _clean_file_if_old(
+                progress_file, cutoff_time, dry_run, "progress"
+            )
+            if file_info:
+                cleaned_files.append(file_info)
+                total_size += file_info["size"]
+
+    return cleaned_files, total_size
+
+
+def _parse_cleanup_options(kwargs: str) -> tuple[dict, str | None]:
+    """Parse and validate cleanup options from kwargs string."""
+    try:
+        extra_kwargs = json.loads(kwargs) if kwargs.strip() else {}
+        return extra_kwargs, None
+    except json.JSONDecodeError as e:
+        return {}, f"Invalid JSON in kwargs: {e}"
+
+
+def _register_clean_tool(mcp_app: t.Any) -> None:
+    @mcp_app.tool()
+    async def clean_crackerjack(args: str = "", kwargs: str = "{}") -> str:
+        """Clean up temporary files, stale progress data, and cached resources.
+
+        Args:
+            args: Optional cleanup scope: 'temp', 'progress', 'cache', 'all' (default)
+            kwargs: JSON with options like {"dry_run": true, "older_than": 24}
+        """
+        context = get_context()
+        if not context:
+            return _create_error_response("Server context not available")
+
+        clean_config = _parse_clean_configuration(args, kwargs)
+        if "error" in clean_config:
+            return _create_error_response(clean_config["error"])
+
+        try:
+            cleanup_results = _execute_cleanup_operations(context, clean_config)
+            return _create_cleanup_response(clean_config, cleanup_results)
+        except Exception as e:
+            return _create_error_response(f"Cleanup failed: {e}")
+
+
+def _parse_clean_configuration(args: str, kwargs: str) -> dict:
+    """Parse and validate cleanup configuration from arguments."""
+    extra_kwargs, parse_error = _parse_cleanup_options(kwargs)
+    if parse_error:
+        return {"error": parse_error}
+
+    return {
+        "scope": args.strip().lower() or "all",
+        "dry_run": extra_kwargs.get("dry_run", False),
+        "older_than_hours": extra_kwargs.get("older_than", 24),
+    }
+
+
+def _execute_cleanup_operations(context: t.Any, clean_config: dict) -> dict:
+    """Execute the cleanup operations based on configuration."""
+    from datetime import datetime, timedelta
+
+    cutoff_time = (
+        datetime.now() - timedelta(hours=clean_config["older_than_hours"])
+    ).timestamp()
+    all_cleaned_files = []
+    total_size = 0
+
+    # Clean temp files
+    if clean_config["scope"] in ("temp", "all"):
+        temp_files, temp_size = _clean_temp_files(cutoff_time, clean_config["dry_run"])
+        all_cleaned_files.extend(temp_files)
+        total_size += temp_size
+
+    # Clean progress files
+    if clean_config["scope"] in ("progress", "all"):
+        progress_files, progress_size = _clean_progress_files(
+            context, cutoff_time, clean_config["dry_run"]
+        )
+        all_cleaned_files.extend(progress_files)
+        total_size += progress_size
+
+    # Clean cache files (if any caching is implemented)
+    if clean_config["scope"] in ("cache", "all"):
+        # Placeholder for future cache cleaning
+        pass
+
+    return {"all_cleaned_files": all_cleaned_files, "total_size": total_size}
+
+
+def _create_cleanup_response(clean_config: dict, cleanup_results: dict) -> str:
+    """Create the cleanup response JSON."""
+    all_cleaned_files = cleanup_results["all_cleaned_files"]
+
+    return json.dumps(
+        {
+            "success": True,
+            "command": "clean_crackerjack",
+            "dry_run": clean_config["dry_run"],
+            "scope": clean_config["scope"],
+            "older_than_hours": clean_config["older_than_hours"],
+            "files_cleaned": len(all_cleaned_files),
+            "total_size_bytes": cleanup_results["total_size"],
+            "files": all_cleaned_files
+            if len(all_cleaned_files) <= 50
+            else all_cleaned_files[:50],
+        },
+        indent=2,
+    )
+
+
+def _handle_config_list(context: t.Any) -> dict[str, t.Any]:
+    """Handle config list action."""
+    return {
+        "project_path": str(context.config.project_path),
+        "rate_limiter": {
+            "enabled": context.rate_limiter is not None,
+            "config": context.rate_limiter.config.__dict__
+            if context.rate_limiter
+            else None,
+        },
+        "progress_dir": str(context.progress_dir),
+        "websocket_port": getattr(context, "websocket_server_port", None),
+    }
+
+
+def _handle_config_get(context: t.Any, key: str) -> dict[str, t.Any]:
+    """Handle config get action."""
+    value = getattr(context.config, key, None)
+    if value is None:
+        value = getattr(context, key, "Key not found")
+
+    return {
+        "success": True,
+        "command": "config_crackerjack",
+        "action": "get",
+        "key": key,
+        "value": str(value),
+    }
+
+
+def _handle_config_validate(context: t.Any) -> dict[str, t.Any]:
+    """Handle config validate action."""
+    validation_results = {
+        "project_path_exists": context.config.project_path.exists(),
+        "progress_dir_writable": context.progress_dir.exists()
+        and context.progress_dir.is_dir(),
+        "rate_limiter_configured": context.rate_limiter is not None,
+    }
+
+    all_valid = all(validation_results.values())
+
+    return {
+        "success": True,
+        "command": "config_crackerjack",
+        "action": "validate",
+        "valid": all_valid,
+        "checks": validation_results,
+    }
+
+
+def _register_config_tool(mcp_app: t.Any) -> None:
+    @mcp_app.tool()
+    async def config_crackerjack(args: str = "", kwargs: str = "{}") -> str:
+        """View or update crackerjack configuration.
+
+        Args:
+            args: Action - 'get <key>', 'set <key=value>', 'list', or 'validate'
+            kwargs: JSON with additional options
+        """
+        context = get_context()
+        if not context:
+            return _create_error_response("Server context not available")
+
+        extra_kwargs, parse_error = _parse_cleanup_options(kwargs)
+        if parse_error:
+            return _create_error_response(parse_error)
+
+        args_parts = args.strip().split() if args.strip() else ["list"]
+        action = args_parts[0].lower()
+
+        try:
+            if action == "list":
+                config_info = _handle_config_list(context)
+                result = {
+                    "success": True,
+                    "command": "config_crackerjack",
+                    "action": "list",
+                    "configuration": config_info,
+                }
+            elif action == "get" and len(args_parts) > 1:
+                result = _handle_config_get(context, args_parts[1])
+            elif action == "validate":
+                result = _handle_config_validate(context)
+            else:
+                return _create_error_response(
+                    f"Invalid action '{action}'. Valid actions: list, get <key>, validate"
+                )
+
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            return _create_error_response(f"Config operation failed: {e}")
+
+
+def _run_hooks_analysis(orchestrator: t.Any, options: t.Any) -> dict:
+    """Run hooks analysis and return results."""
+    fast_result = orchestrator.run_fast_hooks_only(options)
+    comprehensive_result = orchestrator.run_comprehensive_hooks_only(options)
+
+    return {
+        "fast_hooks": "passed" if fast_result else "failed",
+        "comprehensive_hooks": "passed" if comprehensive_result else "failed",
+    }
+
+
+def _run_tests_analysis(orchestrator: t.Any, options: t.Any) -> dict:
+    """Run tests analysis and return results."""
+    test_result = orchestrator.run_testing_phase(options)
+    return {"status": "passed" if test_result else "failed"}
+
+
+def _create_analysis_orchestrator(context: t.Any) -> t.Any:
+    """Create workflow orchestrator for analysis."""
+    from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+
+    return WorkflowOrchestrator(
+        console=context.console,
+        pkg_path=context.config.project_path,
+        dry_run=True,  # Analysis only, no changes
+    )
+
+
+def _register_analyze_tool(mcp_app: t.Any) -> None:
+    @mcp_app.tool()
+    async def analyze_crackerjack(args: str = "", kwargs: str = "{}") -> str:
+        """Analyze code quality without making changes.
+
+        Args:
+            args: Analysis scope - 'hooks', 'tests', 'all' (default)
+            kwargs: JSON with options like {"report_format": "summary"}
+        """
+        context = get_context()
+        if not context:
+            return _create_error_response("Server context not available")
+
+        extra_kwargs, parse_error = _parse_cleanup_options(kwargs)
+        if parse_error:
+            return _create_error_response(parse_error)
+
+        scope = args.strip().lower() or "all"
+        report_format = extra_kwargs.get("report_format", "summary")
+
+        try:
+            from crackerjack.models.config import WorkflowOptions
+
+            orchestrator = _create_analysis_orchestrator(context)
+            options = WorkflowOptions()
+            analysis_results = {}
+
+            if scope in ("hooks", "all"):
+                analysis_results["hooks"] = _run_hooks_analysis(orchestrator, options)
+
+            if scope in ("tests", "all"):
+                analysis_results["tests"] = _run_tests_analysis(orchestrator, options)
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "command": "analyze_crackerjack",
+                    "scope": scope,
+                    "report_format": report_format,
+                    "dry_run": True,
+                    "timestamp": time.time(),
+                    "analysis": analysis_results,
+                },
+                indent=2,
+            )
+
+        except Exception as e:
+            return _create_error_response(f"Analysis failed: {e}")

crackerjack/mcp/tools/workflow_executor.py

@@ -0,0 +1,360 @@
+"""Workflow execution engine for MCP tools.
+
+This module handles the core workflow execution logic, including orchestrator setup,
+iteration management, and result handling. Split from execution_tools.py for better
+separation of concerns.
+"""
+
+import asyncio
+import time
+import typing as t
+import uuid
+
+from crackerjack.mcp.context import get_context
+
+from .progress_tools import _update_progress
+
+
+async def execute_crackerjack_workflow(
+    args: str, kwargs: dict[str, t.Any]
+) -> dict[str, t.Any]:
+    """Execute the main crackerjack workflow with progress tracking."""
+    job_id = str(uuid.uuid4())[:8]
+
+    try:
+        return await _execute_crackerjack_sync(job_id, args, kwargs, get_context())
+    except Exception as e:
+        return {
+            "job_id": job_id,
+            "status": "failed",
+            "error": f"Execution failed: {e}",
+            "timestamp": time.time(),
+        }
+
+
+async def _execute_crackerjack_sync(
+    job_id: str,
+    args: str,
+    kwargs: dict[str, t.Any],
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Execute crackerjack workflow synchronously with progress tracking."""
+    # Initialize execution environment
+    setup_result = await _initialize_execution(job_id, args, kwargs, context)
+    if setup_result.get("status") == "failed":
+        return setup_result
+
+    # Set up orchestrator
+    orchestrator_result = await _setup_orchestrator(
+        job_id, args, kwargs, setup_result["working_dir"], context
+    )
+    if orchestrator_result.get("status") == "failed":
+        return orchestrator_result
+
+    orchestrator = orchestrator_result["orchestrator"]
+
+    # Run workflow iterations
+    return await _run_workflow_iterations(job_id, orchestrator, kwargs, context)
+
+
+async def _initialize_execution(
+    job_id: str,
+    args: str,
+    kwargs: dict[str, t.Any],
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Initialize execution environment and validate parameters."""
+    await _update_progress(
+        job_id,
+        {
+            "type": "initialization",
+            "status": "starting",
+            "message": "Initializing crackerjack execution...",
+        },
+        context,
+    )
+
+    # Validate working directory
+    working_dir = kwargs.get("working_directory", ".")
+    from pathlib import Path
+
+    working_path = Path(working_dir)
+    if not working_path.exists():
+        return {
+            "status": "failed",
+            "error": f"Working directory does not exist: {working_dir}",
+            "job_id": job_id,
+        }
+
+    await _update_progress(
+        job_id,
+        {
+            "type": "initialization",
+            "status": "ready",
+            "working_directory": str(working_path.absolute()),
+        },
+        context,
+    )
+
+    return {
+        "status": "initialized",
+        "working_dir": working_path.absolute(),
+        "job_id": job_id,
+    }
+
+
+async def _setup_orchestrator(
+    job_id: str,
+    args: str,
+    kwargs: dict[str, t.Any],
+    working_dir: t.Any,
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Set up the appropriate orchestrator based on configuration."""
+    await _update_progress(
+        job_id,
+        {
+            "type": "setup",
+            "status": "creating_orchestrator",
+            "message": "Setting up workflow orchestrator...",
+        },
+        context,
+    )
+
+    use_advanced = kwargs.get("advanced_orchestration", True)
+
+    try:
+        if use_advanced:
+            orchestrator = await _create_advanced_orchestrator(
+                working_dir, kwargs, context
+            )
+        else:
+            orchestrator = _create_standard_orchestrator(working_dir, kwargs)
+
+        return {
+            "status": "ready",
+            "orchestrator": orchestrator,
+            "job_id": job_id,
+        }
+
+    except Exception as e:
+        return {
+            "status": "failed",
+            "error": f"Failed to create orchestrator: {e}",
+            "job_id": job_id,
+        }
+
+
+async def _create_advanced_orchestrator(
+    working_dir: t.Any, kwargs: dict[str, t.Any], context: t.Any
+) -> t.Any:
+    """Create advanced async orchestrator with dependency injection."""
+    from pathlib import Path
+
+    from crackerjack.core.async_workflow_orchestrator import AsyncWorkflowOrchestrator
+    from crackerjack.core.enhanced_container import EnhancedContainer
+
+    container = EnhancedContainer()
+
+    # Register services with the container
+    await _register_core_services(container, Path(working_dir))
+
+    orchestrator = AsyncWorkflowOrchestrator(
+        pkg_path=Path(working_dir),
+        container=container,
+    )
+
+    return orchestrator
+
+
+def _create_standard_orchestrator(
+    working_dir: t.Any, kwargs: dict[str, t.Any]
+) -> t.Any:
+    """Create standard synchronous orchestrator."""
+    from pathlib import Path
+
+    from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+
+    return WorkflowOrchestrator(pkg_path=Path(working_dir))
+
+
+async def _register_core_services(container: t.Any, working_dir: t.Any) -> None:
+    """Register core services with the dependency injection container."""
+    from rich.console import Console
+
+    from crackerjack.core.enhanced_container import ServiceLifetime
+    from crackerjack.managers.hook_manager import AsyncHookManager
+    from crackerjack.managers.publish_manager import PublishManager
+    from crackerjack.managers.test_manager import TestManager
+    from crackerjack.models.protocols import (
+        HookManagerProtocol,
+        PublishManagerProtocol,
+        TestManagerProtocol,
+    )
+    from crackerjack.services.enhanced_filesystem import EnhancedFileSystemService
+
+    console = Console()
+
+    # Register managers
+    container.register_service(
+        HookManagerProtocol,
+        AsyncHookManager(console, working_dir),
+        ServiceLifetime.SINGLETON,
+    )
+
+    container.register_service(
+        TestManagerProtocol,
+        TestManager(console, working_dir),
+        ServiceLifetime.SINGLETON,
+    )
+
+    container.register_service(
+        PublishManagerProtocol,
+        PublishManager(console, working_dir),
+        ServiceLifetime.SINGLETON,
+    )
+
+    # Register filesystem service
+    container.register_service(
+        EnhancedFileSystemService,
+        EnhancedFileSystemService(),
+        ServiceLifetime.SINGLETON,
+    )
+
+
+async def _run_workflow_iterations(
+    job_id: str,
+    orchestrator: t.Any,
+    kwargs: dict[str, t.Any],
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Run workflow iterations until completion or max attempts."""
+    options = _create_workflow_options(kwargs)
+    max_iterations = kwargs.get("max_iterations", 10)
+
+    for iteration in range(max_iterations):
+        await _update_progress(
+            job_id,
+            {
+                "type": "iteration",
+                "iteration": iteration + 1,
+                "max_iterations": max_iterations,
+                "status": "running",
+            },
+            context,
+        )
+
+        try:
+            success = await _execute_single_iteration(
+                job_id, orchestrator, options, iteration, context
+            )
+
+            if success:
+                return _create_success_result(job_id, iteration + 1, context)
+
+            # Handle retry logic
+            if iteration < max_iterations - 1:
+                await _handle_iteration_retry(job_id, iteration, context)
+
+        except Exception as e:
+            return await _handle_iteration_error(job_id, iteration, e, context)
+
+    return _create_failure_result(job_id, max_iterations, context)
+
+
+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
+    options = SimpleNamespace()
+    options.test_mode = kwargs.get("test_mode", True)
+    options.ai_agent = kwargs.get("ai_agent", True)
+    options.interactive = kwargs.get("interactive", False)
+    options.benchmark = kwargs.get("benchmark", False)
+    options.skip_hooks = kwargs.get("skip_hooks", False)
+    options.verbose = kwargs.get("verbose", True)
+
+    return options
+
+
+async def _execute_single_iteration(
+    job_id: str,
+    orchestrator: t.Any,
+    options: t.Any,
+    iteration: int,
+    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)
+
+
+def _create_success_result(
+    job_id: str, iterations: int, context: t.Any
+) -> dict[str, t.Any]:
+    """Create success result with completion data."""
+    return {
+        "job_id": job_id,
+        "status": "completed",
+        "iterations": iterations,
+        "result": "All quality checks passed successfully",
+        "timestamp": time.time(),
+        "success": True,
+    }
+
+
+async def _handle_iteration_retry(job_id: str, iteration: int, context: t.Any) -> None:
+    """Handle retry logic between iterations."""
+    await _update_progress(
+        job_id,
+        {
+            "type": "iteration",
+            "iteration": iteration + 1,
+            "status": "retrying",
+            "message": f"Issues found in iteration {iteration + 1}, retrying...",
+        },
+        context,
+    )
+
+    # Brief pause between iterations
+    await asyncio.sleep(1)
+
+
+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(
+        job_id,
+        {
+            "type": "error",
+            "iteration": iteration + 1,
+            "error": str(error),
+            "status": "failed",
+        },
+        context,
+    )
+
+    return {
+        "job_id": job_id,
+        "status": "failed",
+        "error": f"Iteration {iteration + 1} failed: {error}",
+        "timestamp": time.time(),
+        "success": False,
+    }
+
+
+def _create_failure_result(
+    job_id: str, max_iterations: int, context: t.Any
+) -> dict[str, t.Any]:
+    """Create failure result when max iterations exceeded."""
+    return {
+        "job_id": job_id,
+        "status": "failed",
+        "error": f"Maximum iterations ({max_iterations}) reached without success",
+        "timestamp": time.time(),
+        "success": False,
+    }