crackerjack 0.31.10__py3-none-any.whl → 0.31.13__py3-none-any.whl

crackerjack/mcp/service_watchdog.py

@@ -80,7 +80,7 @@ class ServiceWatchdog:
 
         for service in self.services:
             if service.process:
-                console.print(f"[yellow]🛑 Stopping {service.name}...[/yellow]")
+                console.print(f"[yellow]🛑 Stopping {service.name}...[/ yellow]")
                 service.process.terminate()
                 try:
                     service.process.wait(timeout=10)
@@ -112,7 +112,7 @@ class ServiceWatchdog:
             return await self._handle_service_start_error(service, e)
 
     async def _check_websocket_server_running(self, service: ServiceConfig) -> bool:
-        if "websocket - server" in " ".join(service.command):
+        if "websocket-server" in " ".join(service.command):
             if self._is_port_in_use(8675):
                 await self._emit_event(
                     "port_in_use",
@@ -149,7 +149,7 @@ class ServiceWatchdog:
         stdout, stderr = service.process.communicate()
         error_msg = f"Process died (exit: {exit_code})"
         if stderr and stderr.strip():
-            error_msg += f" - {stderr.strip()[:50]}"
+            error_msg += f"-{stderr.strip()[:50]}"
         service.last_error = error_msg
         await self._emit_event("process_died", service.name, error_msg)
         return False
@@ -179,7 +179,7 @@ class ServiceWatchdog:
         return False
 
     async def _handle_websocket_server_monitoring(self, service: ServiceConfig) -> bool:
-        if "websocket - server" not in " ".join(service.command):
+        if "websocket-server" not in " ".join(service.command):
             return False
 
         if self._is_port_in_use(8675):
@@ -276,7 +276,7 @@ class ServiceWatchdog:
         error: Exception,
     ) -> None:
         service.last_error = str(error)
-        console.print(f"[red]❌ Error monitoring {service.name}: {error}[/red]")
+        console.print(f"[red]❌ Error monitoring {service.name}: {error}[/ red]")
         await asyncio.sleep(10.0)
 
     async def _health_check(self, service: ServiceConfig) -> bool:
@@ -294,7 +294,7 @@ class ServiceWatchdog:
             return False
 
         with suppress(Exception):
-            async with self.session.get("http: // localhost: 8675 / ") as response:
+            async with self.session.get("http: / / localhost: 8675 / ") as response:
                 if response.status == 200:
                     data = await response.json()
 
@@ -309,7 +309,7 @@ class ServiceWatchdog:
         current_time = time.time()
         reason = self._determine_restart_reason(service)
 
-        await self._emit_event("restarting", service.name, f"Restarting - {reason}")
+        await self._emit_event("restarting", service.name, f"Restarting-{reason}")
 
         if not await self._check_restart_rate_limit(service, current_time):
             return
@@ -338,7 +338,7 @@ class ServiceWatchdog:
 
         if len(service.restart_timestamps) >= service.max_restarts:
             console.print(
-                f"[red]🚨 {service.name} exceeded restart limit ({service.max_restarts} in {service.restart_window}s)[/red]",
+                f"[red]🚨 {service.name} exceeded restart limit ({service.max_restarts} in {service.restart_window}s)[/ red]",
             )
             service.last_error = "Restart rate limit exceeded"
             await asyncio.sleep(60)
@@ -351,19 +351,19 @@ class ServiceWatchdog:
 
         try:
             console.print(
-                f"[yellow]🔪 Terminating existing {service.name} process (PID: {service.process.pid})[/yellow]",
+                f"[yellow]🔪 Terminating existing {service.name} process (PID: {service.process.pid})[/ yellow]",
             )
             service.process.terminate()
             service.process.wait(timeout=10)
         except subprocess.TimeoutExpired:
-            console.print(f"[red]💀 Force killing {service.name} process[/red]")
+            console.print(f"[red]💀 Force killing {service.name} process[/ red]")
             service.process.kill()
         except Exception as e:
-            console.print(f"[yellow]⚠️ Error terminating {service.name}: {e}[/yellow]")
+            console.print(f"[yellow]⚠️ Error terminating {service.name}: {e}[/ yellow]")
 
     async def _wait_before_restart(self, service: ServiceConfig) -> None:
         console.print(
-            f"[yellow]⏳ Waiting {service.restart_delay}s before restarting {service.name}...[/yellow]",
+            f"[yellow]⏳ Waiting {service.restart_delay}s before restarting {service.name}...[/ yellow]",
         )
         await asyncio.sleep(service.restart_delay)
 
@@ -386,7 +386,7 @@ class ServiceWatchdog:
                 await asyncio.sleep(10.0)
 
             except Exception as e:
-                console.print(f"[red]Error updating display: {e}[/red]")
+                console.print(f"[red]Error updating display: {e}[/ red]")
                 await asyncio.sleep(5.0)
 
     async def _update_status_display(self) -> None:
@@ -402,7 +402,7 @@ class ServiceWatchdog:
             table.add_row(service.name, status, health, restarts, error)
 
         console.print(table)
-        console.print("\n[dim]Press Ctrl + C to stop monitoring[/dim]")
+        console.print("\n[dim]Press Ctrl + C to stop monitoring[/ dim]")
 
     def _create_status_table(self) -> Table:
         table = Table(title="🔍 Crackerjack Service Watchdog")
@@ -415,20 +415,20 @@ class ServiceWatchdog:
 
     def _get_service_status(self, service: ServiceConfig) -> str:
         if service.process and service.process.poll() is None:
-            return "[green]✅ Running[/green]"
-        return "[red]❌ Stopped[/red]"
+            return "[green]✅ Running[/ green]"
+        return "[red]❌ Stopped[/ red]"
 
     def _get_service_health(self, service: ServiceConfig) -> str:
         if service.health_check_url:
             return (
-                "[green]🟢 Healthy[/green]"
+                "[green]🟢 Healthy[/ green]"
                 if service.is_healthy
-                else "[red]🔴 Unhealthy[/red]"
+                else "[red]🔴 Unhealthy[/ red]"
             )
-        return "[dim]N / A[/dim]"
+        return "[dim]N / A[/ dim]"
 
     def _format_error_message(self, error_message: str | None) -> str:
-        error = error_message or "[dim]None[/dim]"
+        error = error_message or "[dim]None[/ dim]"
         if len(error) > 30:
             error = error[:27] + "..."
         return error
@@ -466,20 +466,20 @@ async def create_default_watchdog(
             name="MCP Server",
             command=[
                 python_path,
-                " - m",
+                "-m",
                 "crackerjack",
-                " -- start - mcp - server",
+                "--start-mcp-server",
             ],
         ),
         ServiceConfig(
             name="WebSocket Server",
             command=[
                 python_path,
-                " - m",
+                "-m",
                 "crackerjack",
-                " -- websocket - server",
+                " - - websocket-server",
             ],
-            health_check_url="http: // localhost: 8675 / ",
+            health_check_url="http: / / localhost: 8675 / ",
         ),
     ]
 
@@ -492,7 +492,7 @@ async def main() -> None:
     try:
         await watchdog.start()
     except KeyboardInterrupt:
-        console.print("\n[yellow]🛑 Shutting down watchdog...[/yellow]")
+        console.print("\n[yellow]🛑 Shutting down watchdog...[/ yellow]")
     finally:
         await watchdog.stop()
 

crackerjack/mcp/state.py

@@ -350,6 +350,21 @@ class StateManager:
         checkpoints.sort(key=operator.itemgetter("timestamp"), reverse=True)
         return checkpoints
 
+    def start_session(self) -> None:
+        """Start or initialize a session."""
+        # Session is already initialized in __init__, this is a no-op
+        # but provided for API compatibility
+        self._save_state()
+
+    def complete_session(self) -> None:
+        """Complete the current session."""
+        # Mark session as complete in metadata
+        if not self.session_state.metadata:
+            self.session_state.metadata = {}
+        self.session_state.metadata["status"] = "completed"
+        self.session_state.metadata["completed_time"] = time.time()
+        self._save_state()
+
     async def reset_session(self) -> None:
         async with self._lock:
             self.session_state = SessionState(

crackerjack/mcp/tools/core_tools.py

@@ -1,6 +1,9 @@
 import typing as t
 
 from crackerjack.mcp.context import get_context
+from crackerjack.services.input_validator import (
+    get_input_validator,
+)
 
 
 async def create_task_with_subagent(
@@ -8,31 +11,52 @@ async def create_task_with_subagent(
     prompt: str,
     subagent_type: str,
 ) -> dict[str, t.Any]:
-    """Create a task using a specific subagent type.
+    try:
+        # Input validation with security checks
+        validator = get_input_validator()
+
+        # Validate description
+        desc_result = validator.validate_command_args(description)
+        if not desc_result.valid:
+            return {
+                "success": False,
+                "error": f"Invalid description: {desc_result.error_message}",
+                "validation_type": desc_result.validation_type,
+            }
 
-    This function provides integration with the Task tool for executing
-    user agents and system agents through the intelligent agent system.
+        # Validate prompt
+        prompt_result = validator.validate_command_args(prompt)
+        if not prompt_result.valid:
+            return {
+                "success": False,
+                "error": f"Invalid prompt: {prompt_result.error_message}",
+                "validation_type": prompt_result.validation_type,
+            }
 
-    Args:
-        description: Description of the task
-        prompt: The actual task prompt/content
-        subagent_type: Type of subagent to use
+        # Validate subagent_type (should be safe identifier)
+        subagent_result = validator.sanitizer.sanitize_string(
+            subagent_type, max_length=100, strict_alphanumeric=True
+        )
+        if not subagent_result.valid:
+            return {
+                "success": False,
+                "error": f"Invalid subagent_type: {subagent_result.error_message}",
+                "validation_type": subagent_result.validation_type,
+            }
 
-    Returns:
-        Dictionary with task execution results
-    """
-    try:
-        # For now, return a placeholder result indicating the task would be executed
-        # In a full implementation, this would integrate with the actual Task tool
+        # Use sanitized values
+        sanitized_description = desc_result.sanitized_value or description
+        sanitized_prompt = prompt_result.sanitized_value or prompt
+        sanitized_subagent = subagent_result.sanitized_value
 
         result = {
             "success": True,
-            "description": description,
-            "prompt": prompt,
-            "subagent_type": subagent_type,
-            "result": f"Task would be executed by {subagent_type}: {prompt[:100]}...",
+            "description": sanitized_description,
+            "prompt": sanitized_prompt,
+            "subagent_type": sanitized_subagent,
+            "result": f"Task would be executed by {sanitized_subagent}: {sanitized_prompt[:100]}...",
             "agent_type": "user"
-            if subagent_type
+            if sanitized_subagent
             not in ("general-purpose", "statusline-setup", "output-style-setup")
             else "system",
         }
@@ -42,7 +66,7 @@ async def create_task_with_subagent(
     except Exception as e:
         return {
             "success": False,
-            "error": str(e),
+            "error": f"Task creation failed: {e}",
             "description": description,
             "subagent_type": subagent_type,
         }
@@ -52,7 +76,6 @@ async def _validate_stage_request(context, rate_limiter) -> str | None:
     if not context:
         return '{"error": "Server context not available", "success": false}'
 
-    # Skip rate limiting if not configured
     if rate_limiter and hasattr(rate_limiter, "check_request_allowed"):
         allowed, details = await rate_limiter.check_request_allowed()
         if not allowed:
@@ -61,22 +84,61 @@ async def _validate_stage_request(context, rate_limiter) -> str | None:
 
 
 def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
-    stage = args.strip().lower()
+    try:
+        validator = get_input_validator()
+
+        # Validate stage argument
+        stage_validation = _validate_stage_argument(validator, args)
+        if isinstance(stage_validation, str):
+            return stage_validation
+        stage = stage_validation
+
+        # Validate and parse kwargs
+        kwargs_validation = _validate_kwargs_argument(validator, kwargs)
+        if isinstance(kwargs_validation, str):
+            return kwargs_validation
+        extra_kwargs = kwargs_validation
+
+        return stage, extra_kwargs
+
+    except Exception as e:
+        return f'{{"error": "Stage argument parsing failed: {e}", "success": false}}'
+
+
+def _validate_stage_argument(validator, args: str) -> str:
+    """Validate and sanitize the stage argument."""
+    stage_result = validator.sanitizer.sanitize_string(
+        args.strip(), max_length=50, strict_alphanumeric=True
+    )
+    if not stage_result.valid:
+        return f'{{"error": "Invalid stage argument: {stage_result.error_message}", "success": false}}'
+
+    stage = stage_result.sanitized_value.lower()
     valid_stages = {"fast", "comprehensive", "tests", "cleaning", "init"}
 
     if stage not in valid_stages:
         return f'{{"error": "Invalid stage: {stage}. Valid stages: {valid_stages}", "success": false}}'
 
-    import json
+    return stage
 
+
+def _validate_kwargs_argument(validator, kwargs: str) -> dict | str:
+    """Validate and parse the kwargs argument."""
     extra_kwargs = {}
-    if kwargs.strip():
-        try:
-            extra_kwargs = json.loads(kwargs)
-        except json.JSONDecodeError as e:
-            return f'{{"error": "Invalid JSON in kwargs: {e}", "success": false}}'
+    if not kwargs.strip():
+        return extra_kwargs
+
+    kwargs_result = validator.validate_json_payload(kwargs.strip())
+    if not kwargs_result.valid:
+        return f'{{"error": "Invalid JSON in kwargs: {kwargs_result.error_message}", "success": false}}'
+
+    extra_kwargs = kwargs_result.sanitized_value
+
+    # Additional validation on JSON structure
+    if not isinstance(extra_kwargs, dict):
+        return f'{{"error": "kwargs must be a JSON object, got {type(extra_kwargs).__name__}", "success": false}}'
 
-    return stage, extra_kwargs
+    return extra_kwargs
 
 
 def _configure_stage_options(stage: str) -> "WorkflowOptions":
@@ -90,7 +152,6 @@ def _configure_stage_options(stage: str) -> "WorkflowOptions":
     elif stage == "cleaning":
         options.cleaning.clean = True
     elif stage == "init":
-        # Init stage doesn't use standard workflow options
         options.skip_hooks = True
     return options
 
@@ -110,7 +171,6 @@ def _execute_stage(orchestrator, stage: str, options) -> bool:
 
 
 def _execute_init_stage(orchestrator) -> bool:
-    """Execute project initialization stage."""
     try:
         from pathlib import Path
 
@@ -118,25 +178,21 @@ def _execute_init_stage(orchestrator) -> bool:
         from crackerjack.services.git import GitService
         from crackerjack.services.initialization import InitializationService
 
-        # Get orchestrator dependencies
         console = orchestrator.console
         pkg_path = orchestrator.pkg_path
 
-        # Create service dependencies
         filesystem = FileSystemService()
         git_service = GitService(console, pkg_path)
 
-        # Initialize the service
         init_service = InitializationService(console, filesystem, git_service, pkg_path)
 
-        # Run initialization in current directory
         results = init_service.initialize_project(target_path=Path.cwd())
 
         return results.get("success", False)
 
     except Exception as e:
         if hasattr(orchestrator, "console"):
-            orchestrator.console.print(f"[red]❌[/red] Initialization failed: {e}")
+            orchestrator.console.print(f"[red]❌[/ red] Initialization failed: {e}")
         return False
 
 
@@ -177,11 +233,11 @@ def register_core_tools(mcp_app: t.Any) -> None:
 
 def _get_error_patterns() -> list[tuple[str, str]]:
     return [
-        ("type_error", r"TypeError:|type object .* has no attribute"),
-        ("import_error", r"ImportError:|ModuleNotFoundError:"),
+        ("type_error", r"TypeError: | type object .* has no attribute"),
+        ("import_error", r"ImportError: | ModuleNotFoundError: "),
         ("attribute_error", r"AttributeError: "),
-        ("syntax_error", r"SyntaxError:|invalid syntax"),
-        ("test_failure", r"FAILED|AssertionError:"),
+        ("syntax_error", r"SyntaxError: | invalid syntax"),
+        ("test_failure", r"FAILED | AssertionError: "),
         ("hook_failure", r"hook .* failed"),
     ]
 

crackerjack/mcp/tools/error_analyzer.py

@@ -1,9 +1,3 @@
-"""Error analysis and pattern detection for MCP tools.
-
-This module handles intelligent error analysis, pattern caching, and diagnostic
-recommendations. Split from execution_tools.py for better separation of concerns.
-"""
-
 import typing as t
 from contextlib import suppress
 
@@ -11,7 +5,6 @@ from contextlib import suppress
 def analyze_errors_with_caching(
     context: t.Any, use_cache: bool = True
 ) -> dict[str, t.Any]:
-    """Analyze errors with intelligent caching and pattern detection."""
     try:
         cached_patterns = _get_cached_patterns(context, use_cache)
         return _build_error_analysis(cached_patterns, context)
@@ -26,7 +19,6 @@ def analyze_errors_with_caching(
 
 
 def _get_cached_patterns(context: t.Any, use_cache: bool) -> list[t.Any]:
-    """Get cached error patterns from context."""
     if not use_cache:
         return []
 
@@ -39,7 +31,6 @@ def _get_cached_patterns(context: t.Any, use_cache: bool) -> list[t.Any]:
 
 
 def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.Any]:
-    """Build comprehensive error analysis from patterns."""
     analysis = {
         "status": "success",
         "patterns_found": len(patterns),
@@ -52,7 +43,7 @@ def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.
     if not patterns:
         analysis.update(
             {
-                "message": "No cached error patterns found - this indicates clean execution history",
+                "message": "No cached error patterns found-this indicates clean execution history",
                 "recommendations": [
                     "Continue with current development practices",
                     "Consider running comprehensive quality checks if issues arise",
@@ -61,18 +52,14 @@ def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.
         )
         return analysis
 
-    # Categorize error patterns
     categories = _categorize_error_patterns(patterns)
     analysis["error_categories"] = categories
 
-    # Generate recommendations
     recommendations = _generate_error_recommendations(categories)
     analysis["recommendations"] = recommendations
 
-    # Determine urgency
     analysis["urgency_level"] = _calculate_urgency_level(categories)
 
-    # Generate fix suggestions
     analysis["fix_suggestions"] = _generate_fix_suggestions(categories)
 
     analysis["message"] = (
@@ -83,7 +70,6 @@ def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.
 
 
 def _categorize_error_patterns(patterns: list[t.Any]) -> dict[str, list[t.Any]]:
-    """Categorize error patterns by type."""
     categories = {
         "syntax_errors": [],
         "import_errors": [],
@@ -100,13 +86,10 @@ def _categorize_error_patterns(patterns: list[t.Any]) -> dict[str, list[t.Any]]:
         category = _classify_error_pattern(pattern)
         categories[category].append(pattern)
 
-    # Remove empty categories
     return {k: v for k, v in categories.items() if v}
 
 
 def _classify_error_pattern(pattern: t.Any) -> str:
-    """Classify a single error pattern into a category."""
-    # Convert pattern to string for analysis
     pattern_str = str(pattern).lower()
 
     if any(
@@ -146,7 +129,6 @@ def _classify_error_pattern(pattern: t.Any) -> str:
 
 
 def _generate_error_recommendations(categories: dict[str, list[t.Any]]) -> list[str]:
-    """Generate actionable recommendations based on error categories."""
     recommendations = []
 
     if categories.get("syntax_errors"):
@@ -210,7 +192,6 @@ def _generate_error_recommendations(categories: dict[str, list[t.Any]]) -> list[
             ]
         )
 
-    # Add general recommendations
     if len(categories) > 3:
         recommendations.extend(
             [
@@ -223,26 +204,20 @@ def _generate_error_recommendations(categories: dict[str, list[t.Any]]) -> list[
 
 
 def _calculate_urgency_level(categories: dict[str, list[t.Any]]) -> str:
-    """Calculate urgency level based on error categories and counts."""
     total_errors = sum(len(errors) for errors in categories.values())
 
-    # Security issues are always high priority
     if categories.get("security_issues"):
         return "high"
 
-    # Many test failures indicate critical issues
     if categories.get("test_failures") and len(categories["test_failures"]) > 5:
         return "high"
 
-    # Syntax errors block development
     if categories.get("syntax_errors"):
         return "medium"
 
-    # Large number of total errors
     if total_errors > 20:
         return "medium"
 
-    # Multiple categories indicate systemic issues
     if len(categories) > 4:
         return "medium"
 
@@ -252,7 +227,6 @@ def _calculate_urgency_level(categories: dict[str, list[t.Any]]) -> str:
 def _generate_fix_suggestions(
     categories: dict[str, list[t.Any]],
 ) -> list[dict[str, str]]:
-    """Generate specific fix suggestions with commands."""
     suggestions = []
 
     if categories.get("formatting_issues"):
@@ -260,7 +234,7 @@ def _generate_fix_suggestions(
             {
                 "category": "formatting",
                 "action": "Run code formatting",
-                "command": "python -m crackerjack --skip-tests",
+                "command": "python - m crackerjack - - skip-tests",
                 "description": "Fix formatting and style issues",
             }
         )
@@ -270,7 +244,7 @@ def _generate_fix_suggestions(
             {
                 "category": "types",
                 "action": "Fix type annotations",
-                "command": "python -m crackerjack --ai-agent",
+                "command": "python - m crackerjack - - ai-agent",
                 "description": "Add missing type hints and resolve type conflicts",
             }
         )
@@ -280,7 +254,7 @@ def _generate_fix_suggestions(
             {
                 "category": "tests",
                 "action": "Fix test failures",
-                "command": "python -m crackerjack -t --ai-agent",
+                "command": "python - m crackerjack - t - - ai-agent",
                 "description": "Run tests with AI auto-fixing enabled",
             }
         )
@@ -290,7 +264,7 @@ def _generate_fix_suggestions(
             {
                 "category": "security",
                 "action": "Address security issues",
-                "command": "python -m crackerjack --ai-agent -t",
+                "command": "python - m crackerjack - - ai - agent-t",
                 "description": "Fix security vulnerabilities with AI assistance",
             }
         )
@@ -300,7 +274,7 @@ def _generate_fix_suggestions(
             {
                 "category": "comprehensive",
                 "action": "Full quality check with AI fixing",
-                "command": "python -m crackerjack --ai-agent -t",
+                "command": "python - m crackerjack - - ai - agent-t",
                 "description": "Comprehensive quality check with autonomous fixing",
             }
         )