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

crackerjack/mcp/tools/proactive_tools.py

@@ -1,10 +1,7 @@
 import typing as t
 
-# Helper functions for creating responses and assessments
-
 
 def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
-    """Create architectural assessment with recommendations."""
     assessment = {
         "feature": parsed_kwargs.get("feature", "unknown"),
         "complexity": parsed_kwargs.get("complexity", "medium"),
@@ -14,23 +11,21 @@ def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
 
     recommendations = []
 
-    # Always recommend crackerjack-architect for planning
     recommendations.append(
         {
             "agent": "crackerjack-architect",
             "priority": "high",
             "reason": "Expert architectural planning for crackerjack compliance",
-            "action": 'Task tool with subagent_type="crackerjack-architect" for feature planning and architecture',
+            "action": 'Task tool with subagent_type ="crackerjack-architect" for feature planning and architecture',
             "benefits": [
                 "Prevents violations through proper initial architecture",
                 "Applies crackerjack patterns from the start",
-                "Reduces iteration cycles by 50%+",
+                "Reduces iteration cycles by 50 % +",
                 "Ensures consistency with project standards",
             ],
         }
     )
 
-    # Add complexity-specific recommendations
     complexity = parsed_kwargs.get("complexity", "medium")
     if complexity in ("high", "complex"):
         recommendations.append(
@@ -38,11 +33,10 @@ def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
                 "agent": "refactoring-specialist",
                 "priority": "high",
                 "reason": "Complex features require careful structural planning",
-                "action": 'Task tool with subagent_type="refactoring-specialist" for complexity management',
+                "action": 'Task tool with subagent_type ="refactoring-specialist" for complexity management',
             }
         )
 
-    # Add security recommendations for certain features
     feature = parsed_kwargs.get("feature", "")
     if any(
         keyword in feature.lower() for keyword in ("auth", "security", "api", "data")
@@ -52,7 +46,7 @@ def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
                 "agent": "security-auditor",
                 "priority": "medium",
                 "reason": "Security-sensitive feature requires expert review",
-                "action": 'Task tool with subagent_type="security-auditor" for security validation',
+                "action": 'Task tool with subagent_type ="security-auditor" for security validation',
             }
         )
 
@@ -63,7 +57,6 @@ def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
 
 
 def _create_validation_results(file_path: str) -> dict:
-    """Create validation results for architectural compliance."""
     validation = {
         "file_path": file_path,
         "validation_results": [],
@@ -71,12 +64,11 @@ def _create_validation_results(file_path: str) -> dict:
         "recommendations": [],
     }
 
-    # Check for crackerjack compliance patterns
     compliance_checks = [
         {
             "check": "complexity_compliance",
             "status": "requires_analysis",
-            "message": "Cognitive complexity should be ≤13 per function",
+            "message": "Cognitive complexity should be ≤15 per function",
             "tool": "complexipy",
         },
         {
@@ -105,16 +97,15 @@ def _create_validation_results(file_path: str) -> dict:
 
     validation["validation_results"] = compliance_checks
 
-    # Add proactive recommendations
     validation["recommendations"] = [
-        "Run full crackerjack quality process: python -m crackerjack -t",
+        "Run full crackerjack quality process: python - m crackerjack-t",
         "Use crackerjack-architect for complex refactoring decisions",
         "Apply pattern learning from successful fixes",
         "Validate against architectural plan before committing",
     ]
 
     validation["next_steps"] = [
-        'Task tool with subagent_type="crackerjack-architect" for architectural guidance',
+        'Task tool with subagent_type ="crackerjack-architect" for architectural guidance',
         "Run comprehensive quality checks",
         "Apply learned patterns from pattern cache",
     ]
@@ -123,7 +114,6 @@ def _create_validation_results(file_path: str) -> dict:
 
 
 def _create_pattern_suggestions(problem_context: str) -> dict:
-    """Create pattern suggestions based on context."""
     pattern_suggestions = {
         "context": problem_context,
         "recommended_patterns": [],
@@ -131,32 +121,29 @@ def _create_pattern_suggestions(problem_context: str) -> dict:
         "specialist_agents": [],
     }
 
-    # Add context-specific patterns
     _add_complexity_patterns(pattern_suggestions, problem_context)
     _add_dry_patterns(pattern_suggestions, problem_context)
     _add_performance_patterns(pattern_suggestions, problem_context)
     _add_security_patterns(pattern_suggestions, problem_context)
 
-    # Add specialist agent recommendations
     pattern_suggestions["specialist_agents"] = [
         {
             "agent": "crackerjack-architect",
             "when_to_use": "For architectural decisions and complex pattern application",
-            "action": 'Task tool with subagent_type="crackerjack-architect"',
+            "action": 'Task tool with subagent_type ="crackerjack-architect"',
         },
         {
             "agent": "refactoring-specialist",
             "when_to_use": "For complexity reduction and structural improvements",
-            "action": 'Task tool with subagent_type="refactoring-specialist"',
+            "action": 'Task tool with subagent_type ="refactoring-specialist"',
         },
         {
             "agent": "security-auditor",
             "when_to_use": "For security pattern validation and vulnerability assessment",
-            "action": 'Task tool with subagent_type="security-auditor"',
+            "action": 'Task tool with subagent_type ="security-auditor"',
         },
     ]
 
-    # Implementation guidance
     pattern_suggestions["implementation_guidance"] = [
         "Start with crackerjack-architect for overall planning",
         "Apply one pattern at a time to avoid complexity",
@@ -165,7 +152,6 @@ def _create_pattern_suggestions(problem_context: str) -> dict:
         "Document architectural decisions for team knowledge",
     ]
 
-    # Default patterns if none specified
     if not pattern_suggestions["recommended_patterns"]:
         pattern_suggestions["recommended_patterns"] = [
             {
@@ -183,7 +169,6 @@ def _create_pattern_suggestions(problem_context: str) -> dict:
 
 
 def _add_complexity_patterns(pattern_suggestions: dict, problem_context: str) -> None:
-    """Add complexity-related patterns if relevant."""
     if any(
         keyword in problem_context.lower()
         for keyword in ("complex", "refactor", "cleanup")
@@ -213,7 +198,6 @@ def _add_complexity_patterns(pattern_suggestions: dict, problem_context: str) ->
 
 
 def _add_dry_patterns(pattern_suggestions: dict, problem_context: str) -> None:
-    """Add DRY violation patterns if relevant."""
     if any(
         keyword in problem_context.lower() for keyword in ("duplicate", "repeat", "dry")
     ):
@@ -242,7 +226,6 @@ def _add_dry_patterns(pattern_suggestions: dict, problem_context: str) -> None:
 
 
 def _add_performance_patterns(pattern_suggestions: dict, problem_context: str) -> None:
-    """Add performance patterns if relevant."""
     if any(
         keyword in problem_context.lower()
         for keyword in ("slow", "performance", "optimize")
@@ -272,7 +255,6 @@ def _add_performance_patterns(pattern_suggestions: dict, problem_context: str) -
 
 
 def _add_security_patterns(pattern_suggestions: dict, problem_context: str) -> None:
-    """Add security patterns if relevant."""
     if any(
         keyword in problem_context.lower() for keyword in ("security", "safe", "secure")
     ):
@@ -301,7 +283,6 @@ def _add_security_patterns(pattern_suggestions: dict, problem_context: str) -> N
 
 
 def _create_error_response(error: Exception, recommendation: str) -> str:
-    """Create standardized error response."""
     import json
 
     return json.dumps(
@@ -318,23 +299,18 @@ def _create_error_response(error: Exception, recommendation: str) -> str:
 
 
 def register_proactive_tools(mcp_app: t.Any) -> None:
-    """Register proactive planning and execution tools."""
     return _register_proactive_tools(mcp_app)
 
 
 def _register_proactive_tools(mcp_app: t.Any) -> None:
-    """Register proactive planning and execution tools."""
     _register_plan_development_tool(mcp_app)
     _register_validate_architecture_tool(mcp_app)
     _register_suggest_patterns_tool(mcp_app)
 
 
 def _register_plan_development_tool(mcp_app: t.Any) -> None:
-    """Register the plan_development tool."""
-
     @mcp_app.tool()
     async def plan_development(args: str, kwargs: str) -> str:
-        """Plan development approach using crackerjack-architect specialist."""
         import json
 
         try:
@@ -346,11 +322,8 @@ def _register_plan_development_tool(mcp_app: t.Any) -> None:
 
 
 def _register_validate_architecture_tool(mcp_app: t.Any) -> None:
-    """Register the validate_architecture tool."""
-
     @mcp_app.tool()
     async def validate_architecture(args: str, kwargs: str) -> str:
-        """Validate code against architectural patterns and crackerjack standards."""
         import json
 
         try:
@@ -360,16 +333,13 @@ def _register_validate_architecture_tool(mcp_app: t.Any) -> None:
             return json.dumps(validation, indent=2)
         except Exception as e:
             return _create_error_response(
-                e, "Run standard crackerjack validation: python -m crackerjack"
+                e, "Run standard crackerjack validation: python-m crackerjack"
             )
 
 
 def _register_suggest_patterns_tool(mcp_app: t.Any) -> None:
-    """Register the suggest_patterns tool."""
-
     @mcp_app.tool()
     async def suggest_patterns(args: str, kwargs: str) -> str:
-        """Suggest crackerjack patterns for current development context."""
         import json
 
         try:
@@ -380,5 +350,5 @@ def _register_suggest_patterns_tool(mcp_app: t.Any) -> None:
         except Exception as e:
             return _create_error_response(
                 e,
-                'Use Task tool with subagent_type="crackerjack-architect" for expert guidance',
+                'Use Task tool with subagent_type ="crackerjack-architect" for expert guidance',
             )

crackerjack/mcp/tools/progress_tools.py

@@ -4,25 +4,30 @@ import typing as t
 from pathlib import Path
 
 from crackerjack.mcp.context import get_context
+from crackerjack.services.input_validator import get_input_validator
 
 
 def _create_progress_file(job_id: str) -> Path:
-    import re
     import tempfile
 
-    if not job_id or not isinstance(job_id, str):
-        msg = f"Invalid job_id: {job_id}"
-        raise ValueError(msg)
-    if not re.match(r"^[a-zA-Z0-9_-]+$", job_id):
-        msg = f"Invalid job_id format: {job_id}"
+    # Use secure input validation
+    job_id_result = get_input_validator().validate_job_id(job_id)
+
+    if not job_id_result.valid:
+        msg = f"Invalid job_id: {job_id_result.error_message}"
         raise ValueError(msg)
 
+    # Use sanitized job ID
+    sanitized_job_id = job_id_result.sanitized_value
+
     context = get_context()
     if context:
-        return context.progress_dir / f"job-{job_id}.json"
+        return context.progress_dir / f"job-{sanitized_job_id}.json"
+
+    # Create secure temporary directory
     progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
-    progress_dir.mkdir(exist_ok=True)
-    return progress_dir / f"job-{job_id}.json"
+    progress_dir.mkdir(exist_ok=True, mode=0o750)  # Restrictive permissions
+    return progress_dir / f"job-{sanitized_job_id}.json"
 
 
 def _clamp_progress(value: int) -> int:
@@ -96,7 +101,6 @@ def _update_progress(
     job_id: str,
     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,
@@ -162,7 +166,7 @@ def _handle_get_job_progress(job_id: str) -> str:
         return f'{{"error": "Failed to get progress for job {job_id}: {e}"}}'
 
 
-def _execute_session_action(
+async def _execute_session_action(
     state_manager,
     action: str,
     checkpoint_name: str | None,
@@ -174,7 +178,7 @@ def _execute_session_action(
 
     if action == "checkpoint":
         checkpoint_name = checkpoint_name or f"checkpoint_{context.get_current_time()}"
-        state_manager.create_checkpoint(checkpoint_name)
+        await state_manager.save_checkpoint(checkpoint_name)
         return f'{{"status": "checkpoint_created", "action": "checkpoint", "name": "{checkpoint_name}"}}'
 
     if action == "complete":
@@ -188,7 +192,9 @@ def _execute_session_action(
     return f'{{"error": "Invalid action: {action}. Valid actions: start, checkpoint, complete, reset"}}'
 
 
-def _handle_session_management(action: str, checkpoint_name: str | None = None) -> str:
+async def _handle_session_management(
+    action: str, checkpoint_name: str | None = None
+) -> str:
     context = get_context()
     if not context:
         return '{"error": "Server context not available"}'
@@ -198,7 +204,9 @@ def _handle_session_management(action: str, checkpoint_name: str | None = None)
         if not state_manager:
             return '{"error": "State manager not available"}'
 
-        return _execute_session_action(state_manager, action, checkpoint_name, context)
+        return await _execute_session_action(
+            state_manager, action, checkpoint_name, context
+        )
 
     except Exception as e:
         return f'{{"error": "Session management failed: {e}"}}'
@@ -214,4 +222,4 @@ def register_progress_tools(mcp_app: t.Any) -> None:
         action: str,
         checkpoint_name: str | None = None,
     ) -> str:
-        return _handle_session_management(action, checkpoint_name)
+        return await _handle_session_management(action, checkpoint_name)

crackerjack/mcp/tools/utility_tools.py

@@ -8,12 +8,10 @@ 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)
@@ -22,7 +20,6 @@ def register_utility_tools(mcp_app: t.Any) -> None:
 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
@@ -33,14 +30,13 @@ def _clean_file_if_old(
 
 
 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.*")
+    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")
@@ -54,7 +50,6 @@ def _clean_temp_files(cutoff_time: float, dry_run: bool) -> tuple[list[dict], in
 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
 
@@ -71,7 +66,6 @@ def _clean_progress_files(
 
 
 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
@@ -82,12 +76,6 @@ def _parse_cleanup_options(kwargs: str) -> tuple[dict, str | None]:
 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")
@@ -104,7 +92,6 @@ def _register_clean_tool(mcp_app: t.Any) -> None:
 
 
 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}
@@ -117,7 +104,6 @@ def _parse_clean_configuration(args: str, kwargs: str) -> dict:
 
 
 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 = (
@@ -126,13 +112,11 @@ def _execute_cleanup_operations(context: t.Any, clean_config: dict) -> dict:
     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"]
@@ -140,16 +124,13 @@ def _execute_cleanup_operations(context: t.Any, clean_config: dict) -> dict:
         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(
@@ -170,7 +151,6 @@ def _create_cleanup_response(clean_config: dict, cleanup_results: dict) -> str:
 
 
 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": {
@@ -185,7 +165,6 @@ def _handle_config_list(context: t.Any) -> dict[str, t.Any]:
 
 
 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")
@@ -200,7 +179,6 @@ def _handle_config_get(context: t.Any, key: str) -> dict[str, t.Any]:
 
 
 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()
@@ -222,12 +200,6 @@ def _handle_config_validate(context: t.Any) -> dict[str, t.Any]:
 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")
@@ -254,7 +226,7 @@ def _register_config_tool(mcp_app: t.Any) -> None:
                 result = _handle_config_validate(context)
             else:
                 return _create_error_response(
-                    f"Invalid action '{action}'. Valid actions: list, get <key>, validate"
+                    f"Invalid action '{action}'. Valid actions: list, get < key >, validate"
                 )
 
             return json.dumps(result, indent=2)
@@ -264,7 +236,6 @@ def _register_config_tool(mcp_app: t.Any) -> None:
 
 
 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)
 
@@ -275,31 +246,23 @@ def _run_hooks_analysis(orchestrator: t.Any, options: t.Any) -> dict:
 
 
 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
+        dry_run=True,
     )
 
 
 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")