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

crackerjack/mcp/tools/core_tools.py

@@ -0,0 +1,249 @@
+import typing as t
+
+from crackerjack.mcp.context import get_context
+
+
+async def create_task_with_subagent(
+    description: str,
+    prompt: str,
+    subagent_type: str,
+) -> dict[str, t.Any]:
+    """Create a task using a specific subagent type.
+
+    This function provides integration with the Task tool for executing
+    user agents and system agents through the intelligent agent system.
+
+    Args:
+        description: Description of the task
+        prompt: The actual task prompt/content
+        subagent_type: Type of subagent to use
+
+    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
+
+        result = {
+            "success": True,
+            "description": description,
+            "prompt": prompt,
+            "subagent_type": subagent_type,
+            "result": f"Task would be executed by {subagent_type}: {prompt[:100]}...",
+            "agent_type": "user"
+            if subagent_type
+            not in ("general-purpose", "statusline-setup", "output-style-setup")
+            else "system",
+        }
+
+        return result
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "description": description,
+            "subagent_type": subagent_type,
+        }
+
+
+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:
+            return f'{{"error": "Rate limit exceeded: {details.get("reason", "unknown")}", "success": false}}'
+    return None
+
+
+def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
+    stage = args.strip().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
+
+    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}}'
+
+    return stage, extra_kwargs
+
+
+def _configure_stage_options(stage: str) -> "WorkflowOptions":
+    from crackerjack.models.config import WorkflowOptions
+
+    options = WorkflowOptions()
+    if stage in {"fast", "comprehensive"}:
+        options.skip_hooks = False
+    elif stage == "tests":
+        options.testing.test = True
+    elif stage == "cleaning":
+        options.cleaning.clean = True
+    elif stage == "init":
+        # Init stage doesn't use standard workflow options
+        options.skip_hooks = True
+    return options
+
+
+def _execute_stage(orchestrator, stage: str, options) -> bool:
+    if stage == "fast":
+        return orchestrator.run_fast_hooks_only(options)
+    if stage == "comprehensive":
+        return orchestrator.run_comprehensive_hooks_only(options)
+    if stage == "tests":
+        return orchestrator.run_testing_phase(options)
+    if stage == "cleaning":
+        return orchestrator.run_cleaning_phase(options)
+    if stage == "init":
+        return _execute_init_stage(orchestrator)
+    return False
+
+
+def _execute_init_stage(orchestrator) -> bool:
+    """Execute project initialization stage."""
+    try:
+        from pathlib import Path
+
+        from crackerjack.services.filesystem import FileSystemService
+        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}")
+        return False
+
+
+def register_core_tools(mcp_app: t.Any) -> None:
+    @mcp_app.tool()
+    async def run_crackerjack_stage(args: str, kwargs: str) -> str:
+        context = get_context()
+        rate_limiter = context.rate_limiter if context else None
+
+        validation_error = await _validate_stage_request(context, rate_limiter)
+        if validation_error:
+            return validation_error
+
+        try:
+            from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+
+            parse_result = _parse_stage_args(args, kwargs)
+            if isinstance(parse_result, str):
+                return parse_result
+
+            stage, extra_kwargs = parse_result
+
+            orchestrator = WorkflowOrchestrator(
+                console=context.console,
+                pkg_path=context.config.project_path,
+                dry_run=extra_kwargs.get("dry_run", False),
+            )
+
+            options = _configure_stage_options(stage)
+            success = _execute_stage(orchestrator, stage, options)
+
+            return f'{{"success": {str(success).lower()}, "stage": "{stage}"}}'
+
+        except Exception as e:
+            context.safe_print(f"Error executing stage {args}: {e}")
+            return f'{{"error": "Stage execution failed: {e}", "success": false}}'
+
+
+def _get_error_patterns() -> list[tuple[str, str]]:
+    return [
+        ("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:"),
+        ("hook_failure", r"hook .* failed"),
+    ]
+
+
+def _get_error_suggestion(error_type: str) -> str:
+    suggestions = {
+        "type_error": "Check type annotations and ensure proper imports",
+        "import_error": "Verify module exists and is properly installed",
+        "test_failure": "Review test assertions and expected behavior",
+        "hook_failure": "Run hooks individually to identify specific failures",
+    }
+    return suggestions.get(error_type) or "No specific suggestion available"
+
+
+def _detect_errors_and_suggestions(
+    text: str,
+    include_suggestions: bool,
+) -> tuple[list[str], list[str]]:
+    import re
+
+    detected_errors = []
+    suggestions = []
+
+    for error_type, pattern in _get_error_patterns():
+        if re.search(pattern, text, re.IGNORECASE):
+            detected_errors.append(error_type)
+            if include_suggestions:
+                suggestions.append(_get_error_suggestion(error_type))
+
+    return detected_errors, suggestions
+
+
+def register_analyze_errors_tool(mcp_app: t.Any) -> None:
+    @mcp_app.tool()
+    async def analyze_errors(output: str = "", include_suggestions: bool = True) -> str:
+        context = get_context()
+        if not context:
+            return '{"error": "Server context not available"}'
+
+        try:
+            from crackerjack.services.debug import get_ai_agent_debugger
+
+            debugger = get_ai_agent_debugger()
+            if not debugger.enabled:
+                return '{"analysis": "Debugging not enabled", "suggestions": []}'
+
+            analysis_text = output or "No specific output provided"
+            detected_errors, suggestions = _detect_errors_and_suggestions(
+                analysis_text,
+                include_suggestions,
+            )
+
+            result = {
+                "analysis": f"Detected {len(detected_errors)} error types",
+                "error_types": detected_errors,
+                "suggestions": suggestions if include_suggestions else [],
+                "raw_output_length": len(analysis_text),
+            }
+
+            import json
+
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            return f'{{"error": "Error analysis failed: {e}"}}'

crackerjack/mcp/tools/error_analyzer.py

@@ -0,0 +1,308 @@
+"""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
+
+
+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)
+
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Error analysis failed: {e}",
+            "recommendations": [],
+            "patterns": [],
+        }
+
+
+def _get_cached_patterns(context: t.Any, use_cache: bool) -> list[t.Any]:
+    """Get cached error patterns from context."""
+    if not use_cache:
+        return []
+
+    with suppress(Exception):
+        cache = getattr(context, "cache", None)
+        if cache and hasattr(cache, "get_error_patterns"):
+            return cache.get_error_patterns()
+
+    return []
+
+
+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),
+        "recommendations": [],
+        "error_categories": {},
+        "fix_suggestions": [],
+        "urgency_level": "low",
+    }
+
+    if not patterns:
+        analysis.update(
+            {
+                "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",
+                ],
+            }
+        )
+        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"] = (
+        f"Found {len(patterns)} cached error patterns across {len(categories)} categories"
+    )
+
+    return analysis
+
+
+def _categorize_error_patterns(patterns: list[t.Any]) -> dict[str, list[t.Any]]:
+    """Categorize error patterns by type."""
+    categories = {
+        "syntax_errors": [],
+        "import_errors": [],
+        "type_errors": [],
+        "test_failures": [],
+        "security_issues": [],
+        "complexity_issues": [],
+        "dependency_issues": [],
+        "formatting_issues": [],
+        "unknown": [],
+    }
+
+    for pattern in patterns:
+        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(
+        keyword in pattern_str
+        for keyword in ("syntax", "invalid syntax", "unexpected token")
+    ):
+        return "syntax_errors"
+    elif any(
+        keyword in pattern_str for keyword in ("import", "module", "no module named")
+    ):
+        return "import_errors"
+    elif any(
+        keyword in pattern_str for keyword in ("type", "annotation", "mypy", "pyright")
+    ):
+        return "type_errors"
+    elif any(
+        keyword in pattern_str for keyword in ("test", "assert", "pytest", "failed")
+    ):
+        return "test_failures"
+    elif any(
+        keyword in pattern_str for keyword in ("security", "bandit", "vulnerability")
+    ):
+        return "security_issues"
+    elif any(
+        keyword in pattern_str for keyword in ("complexity", "complex", "cognitive")
+    ):
+        return "complexity_issues"
+    elif any(
+        keyword in pattern_str for keyword in ("dependency", "requirement", "package")
+    ):
+        return "dependency_issues"
+    elif any(
+        keyword in pattern_str for keyword in ("format", "style", "ruff", "black")
+    ):
+        return "formatting_issues"
+    return "unknown"
+
+
+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"):
+        recommendations.append(
+            "🔧 Review syntax errors and fix basic Python syntax issues"
+        )
+
+    if categories.get("import_errors"):
+        recommendations.extend(
+            [
+                "📦 Check imports and module dependencies",
+                "🔍 Verify all required packages are installed",
+            ]
+        )
+
+    if categories.get("type_errors"):
+        recommendations.extend(
+            [
+                "🏷️ Add missing type annotations",
+                "🔧 Fix type mismatches and annotation issues",
+            ]
+        )
+
+    if categories.get("test_failures"):
+        recommendations.extend(
+            [
+                "🧪 Fix failing tests and improve test reliability",
+                "🔬 Review test fixtures and dependencies",
+            ]
+        )
+
+    if categories.get("security_issues"):
+        recommendations.extend(
+            [
+                "🔒 Address security vulnerabilities immediately",
+                "🛡️ Follow security best practices",
+            ]
+        )
+
+    if categories.get("complexity_issues"):
+        recommendations.extend(
+            [
+                "📐 Refactor complex functions to reduce cognitive load",
+                "🔄 Break down large functions into smaller components",
+            ]
+        )
+
+    if categories.get("dependency_issues"):
+        recommendations.extend(
+            [
+                "📚 Update dependency management",
+                "🔄 Review and clean up requirements",
+            ]
+        )
+
+    if categories.get("formatting_issues"):
+        recommendations.extend(
+            [
+                "💅 Apply code formatting and style fixes",
+                "📋 Ensure consistent code style",
+            ]
+        )
+
+    # Add general recommendations
+    if len(categories) > 3:
+        recommendations.extend(
+            [
+                "🎯 Consider running AI agent auto-fixing for comprehensive resolution",
+                "📊 Monitor quality metrics to prevent regression",
+            ]
+        )
+
+    return recommendations
+
+
+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"
+
+    return "low"
+
+
+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"):
+        suggestions.append(
+            {
+                "category": "formatting",
+                "action": "Run code formatting",
+                "command": "python -m crackerjack --skip-tests",
+                "description": "Fix formatting and style issues",
+            }
+        )
+
+    if categories.get("type_errors"):
+        suggestions.append(
+            {
+                "category": "types",
+                "action": "Fix type annotations",
+                "command": "python -m crackerjack --ai-agent",
+                "description": "Add missing type hints and resolve type conflicts",
+            }
+        )
+
+    if categories.get("test_failures"):
+        suggestions.append(
+            {
+                "category": "tests",
+                "action": "Fix test failures",
+                "command": "python -m crackerjack -t --ai-agent",
+                "description": "Run tests with AI auto-fixing enabled",
+            }
+        )
+
+    if categories.get("security_issues"):
+        suggestions.append(
+            {
+                "category": "security",
+                "action": "Address security issues",
+                "command": "python -m crackerjack --ai-agent -t",
+                "description": "Fix security vulnerabilities with AI assistance",
+            }
+        )
+
+    if len(categories) > 3:
+        suggestions.append(
+            {
+                "category": "comprehensive",
+                "action": "Full quality check with AI fixing",
+                "command": "python -m crackerjack --ai-agent -t",
+                "description": "Comprehensive quality check with autonomous fixing",
+            }
+        )
+
+    return suggestions