crackerjack 0.37.9__py3-none-any.whl → 0.38.0__py3-none-any.whl

crackerjack/__init__.py

@@ -30,7 +30,7 @@ from .errors import (
     check_file_exists,
     handle_error,
 )
-from .interactive import WorkflowOptions
+from .interactive import InteractiveWorkflowOptions as WorkflowOptions
 
 try:
     from importlib.metadata import version

crackerjack/api.py

@@ -8,8 +8,7 @@ from rich.console import Console
 from .code_cleaner import CleaningResult, CodeCleaner, PackageCleaningResult
 from .core.workflow_orchestrator import WorkflowOrchestrator
 from .errors import CrackerjackError, ErrorCode
-from .interactive import InteractiveCLI
-from .interactive import WorkflowOptions as InteractiveWorkflowOptions
+from .interactive import InteractiveCLI, InteractiveWorkflowOptions
 from .models.config import WorkflowOptions
 from .services.regex_patterns import SAFE_PATTERNS
 

crackerjack/core/workflow_orchestrator.py

@@ -169,22 +169,33 @@ class WorkflowPipeline:
 
     def _initialize_zuban_lsp(self, options: OptionsProtocol) -> None:
         """Initialize Zuban LSP server if not disabled."""
-        # Check if LSP is disabled via CLI flag or configuration
+        if self._should_skip_zuban_lsp(options):
+            return
+
+        if self._is_zuban_lsp_already_running():
+            return
+
+        self._start_zuban_lsp_server(options)
+
+    def _should_skip_zuban_lsp(self, options: OptionsProtocol) -> bool:
+        """Check if Zuban LSP server should be skipped."""
         if getattr(options, "no_zuban_lsp", False):
             self.logger.debug("Zuban LSP server disabled by --no-zuban-lsp flag")
-            return
+            return True
 
-        # Get configuration from options (will use config system if available)
         config = getattr(options, "zuban_lsp", None)
         if config and not config.enabled:
             self.logger.debug("Zuban LSP server disabled in configuration")
-            return
+            return True
 
         if config and not config.auto_start:
             self.logger.debug("Zuban LSP server auto-start disabled in configuration")
-            return
+            return True
 
-        # Check if LSP server is already running to avoid duplicates
+        return False
+
+    def _is_zuban_lsp_already_running(self) -> bool:
+        """Check if LSP server is already running to avoid duplicates."""
         from crackerjack.services.server_manager import find_zuban_lsp_processes
 
         existing_processes = find_zuban_lsp_processes()
@@ -192,20 +203,17 @@ class WorkflowPipeline:
             self.logger.debug(
                 f"Zuban LSP server already running (PID: {existing_processes[0]['pid']})"
             )
-            return
+            return True
+        return False
 
-        # Auto-start LSP server in background
+    def _start_zuban_lsp_server(self, options: OptionsProtocol) -> None:
+        """Start the Zuban LSP server in background."""
         try:
             import subprocess
             import sys
 
-            # Use configuration values if available, otherwise fallback to CLI options
-            if config:
-                zuban_lsp_port = config.port
-                zuban_lsp_mode = config.mode
-            else:
-                zuban_lsp_port = getattr(options, "zuban_lsp_port", 8677)
-                zuban_lsp_mode = getattr(options, "zuban_lsp_mode", "stdio")
+            config = getattr(options, "zuban_lsp", None)
+            zuban_lsp_port, zuban_lsp_mode = self._get_zuban_lsp_config(options, config)
 
             cmd = [
                 sys.executable,
@@ -232,6 +240,17 @@ class WorkflowPipeline:
         except Exception as e:
             self.logger.warning(f"Failed to auto-start Zuban LSP server: {e}")
 
+    def _get_zuban_lsp_config(
+        self, options: OptionsProtocol, config: any
+    ) -> tuple[int, str]:
+        """Get Zuban LSP configuration values."""
+        if config:
+            return config.port, config.mode
+        return (
+            getattr(options, "zuban_lsp_port", 8677),
+            getattr(options, "zuban_lsp_mode", "stdio"),
+        )
+
     def _log_zuban_lsp_status(self) -> None:
         """Display current Zuban LSP server status during workflow startup."""
         from crackerjack.services.server_manager import find_zuban_lsp_processes
@@ -351,36 +370,9 @@ class WorkflowPipeline:
             return
 
         try:
-            # Gather performance metrics from the workflow execution
-            {
-                "workflow_id": workflow_id,
-                "total_duration": duration,
-                "success": success,
-                "cache_metrics": self._cache.get_stats() if self._cache else {},
-                "memory_metrics": self._memory_optimizer.get_stats()
-                if hasattr(self._memory_optimizer, "get_stats")
-                else {},
-            }
-
-            # Generate benchmark comparison
+            self._gather_performance_metrics(workflow_id, duration, success)
             benchmark_results = await self._performance_benchmarks.run_benchmark_suite()
-
-            # Display compact performance summary
-            if benchmark_results:
-                self.console.print("\n[cyan]📊 Performance Benchmark Summary[/cyan]")
-                self.console.print(f"Workflow Duration: [bold]{duration:.2f}s[/bold]")
-
-                # Show key performance improvements if available
-                for result in benchmark_results.results[:3]:  # Top 3 results
-                    if result.time_improvement_percentage > 0:
-                        self.console.print(
-                            f"[green]⚡[/green] {result.test_name}: {result.time_improvement_percentage:.1f}% faster"
-                        )
-
-                    if result.cache_hit_ratio > 0:
-                        self.console.print(
-                            f"[blue]🎯[/blue] Cache efficiency: {result.cache_hit_ratio:.0%}"
-                        )
+            self._display_benchmark_results(benchmark_results, duration)
 
         except Exception as e:
             self.console.print(
@@ -390,6 +382,52 @@ class WorkflowPipeline:
         if self.debugger.enabled:
             self.debugger.print_debug_summary()
 
+    def _gather_performance_metrics(
+        self, workflow_id: str, duration: float, success: bool
+    ) -> dict:
+        """Gather performance metrics from workflow execution."""
+        return {
+            "workflow_id": workflow_id,
+            "total_duration": duration,
+            "success": success,
+            "cache_metrics": self._cache.get_stats() if self._cache else {},
+            "memory_metrics": self._memory_optimizer.get_stats()
+            if hasattr(self._memory_optimizer, "get_stats")
+            else {},
+        }
+
+    def _display_benchmark_results(
+        self, benchmark_results: t.Any, duration: float
+    ) -> None:
+        """Display compact performance summary."""
+        if not benchmark_results:
+            return
+
+        self.console.print("\n[cyan]📊 Performance Benchmark Summary[/cyan]")
+        self.console.print(f"Workflow Duration: [bold]{duration:.2f}s[/bold]")
+
+        self._show_performance_improvements(benchmark_results)
+
+    def _show_performance_improvements(self, benchmark_results: t.Any) -> None:
+        """Show key performance improvements from benchmark results."""
+        for result in benchmark_results.results[:3]:  # Top 3 results
+            self._display_time_improvement(result)
+            self._display_cache_efficiency(result)
+
+    def _display_time_improvement(self, result: t.Any) -> None:
+        """Display time improvement percentage if available."""
+        if result.time_improvement_percentage > 0:
+            self.console.print(
+                f"[green]⚡[/green] {result.test_name}: {result.time_improvement_percentage:.1f}% faster"
+            )
+
+    def _display_cache_efficiency(self, result: t.Any) -> None:
+        """Display cache hit ratio if available."""
+        if result.cache_hit_ratio > 0:
+            self.console.print(
+                f"[blue]🎯[/blue] Cache efficiency: {result.cache_hit_ratio:.0%}"
+            )
+
     def _handle_user_interruption(self) -> bool:
         self.console.print("Interrupted by user")
         self.session.fail_task("workflow", "Interrupted by user")
@@ -525,40 +563,52 @@ class WorkflowPipeline:
             if not self._quality_intelligence:
                 return "Quality intelligence not available"
 
-            # Analyze recent quality trends and anomalies
             anomalies = self._quality_intelligence.detect_anomalies()
             patterns = self._quality_intelligence.identify_patterns()
 
-            # Make intelligent recommendations based on current state
-            recommendations = []
-            if anomalies:
-                high_severity_anomalies = [
-                    a for a in anomalies if a.severity.name in ("CRITICAL", "HIGH")
-                ]
-                if high_severity_anomalies:
-                    recommendations.append(
-                        "comprehensive analysis recommended due to quality anomalies"
-                    )
-                else:
-                    recommendations.append("standard quality checks sufficient")
-
-            if patterns:
-                improving_patterns = [
-                    p for p in patterns if p.trend_direction.name == "IMPROVING"
-                ]
-                if improving_patterns:
-                    recommendations.append("quality trending upward")
-                else:
-                    recommendations.append("quality monitoring active")
-
-            if not recommendations:
-                recommendations.append("baseline quality analysis active")
-
+            recommendations = self._build_quality_recommendations(anomalies, patterns)
             return "; ".join(recommendations)
 
         except Exception as e:
             return f"Quality intelligence analysis failed: {str(e)[:50]}..."
 
+    def _build_quality_recommendations(
+        self, anomalies: t.Any, patterns: t.Any
+    ) -> list[str]:
+        """Build quality recommendations based on anomalies and patterns."""
+        recommendations = []
+
+        if anomalies:
+            recommendations.extend(self._analyze_anomalies(anomalies))
+
+        if patterns:
+            recommendations.extend(self._analyze_patterns(patterns))
+
+        if not recommendations:
+            recommendations.append("baseline quality analysis active")
+
+        return recommendations
+
+    def _analyze_anomalies(self, anomalies: t.Any) -> list[str]:
+        """Analyze anomalies and return recommendations."""
+        high_severity_anomalies = [
+            a for a in anomalies if a.severity.name in ("CRITICAL", "HIGH")
+        ]
+
+        if high_severity_anomalies:
+            return ["comprehensive analysis recommended due to quality anomalies"]
+        return ["standard quality checks sufficient"]
+
+    def _analyze_patterns(self, patterns: t.Any) -> list[str]:
+        """Analyze patterns and return recommendations."""
+        improving_patterns = [
+            p for p in patterns if p.trend_direction.name == "IMPROVING"
+        ]
+
+        if improving_patterns:
+            return ["quality trending upward"]
+        return ["quality monitoring active"]
+
     async def _execute_test_workflow(
         self, options: OptionsProtocol, workflow_id: str
     ) -> bool:
@@ -886,27 +936,36 @@ class WorkflowPipeline:
     def _execute_standard_hooks_workflow(self, options: OptionsProtocol) -> bool:
         self._update_hooks_status_running()
 
-        fast_hooks_success = self._run_fast_hooks_phase(options)
-        if not fast_hooks_success:
+        if not self._execute_fast_hooks_workflow(options):
             self._handle_hooks_completion(False)
             return False
 
-        if getattr(options, "clean", False):
-            if not self._run_code_cleaning_phase(options):
-                self._handle_hooks_completion(False)
-                return False
-
-            if not self._run_post_cleaning_fast_hooks(options):
-                self._handle_hooks_completion(False)
-                return False
-            self._mark_code_cleaning_complete()
+        if not self._execute_cleaning_workflow_if_needed(options):
+            self._handle_hooks_completion(False)
+            return False
 
         comprehensive_success = self._run_comprehensive_hooks_phase(options)
+        self._handle_hooks_completion(comprehensive_success)
+
+        return comprehensive_success
 
-        hooks_success = fast_hooks_success and comprehensive_success
-        self._handle_hooks_completion(hooks_success)
+    def _execute_fast_hooks_workflow(self, options: OptionsProtocol) -> bool:
+        """Execute fast hooks phase."""
+        return self._run_fast_hooks_phase(options)
 
-        return hooks_success
+    def _execute_cleaning_workflow_if_needed(self, options: OptionsProtocol) -> bool:
+        """Execute cleaning workflow if requested."""
+        if not getattr(options, "clean", False):
+            return True
+
+        if not self._run_code_cleaning_phase(options):
+            return False
+
+        if not self._run_post_cleaning_fast_hooks(options):
+            return False
+
+        self._mark_code_cleaning_complete()
+        return True
 
     def _update_hooks_status_running(self) -> None:
         if self._has_mcp_state_manager():
@@ -1116,15 +1175,16 @@ class WorkflowPipeline:
         return test_success
 
     def _should_verify_hook_fixes(self, fixes_applied: list[str]) -> bool:
-        hook_fixes = [
-            f
-            for f in fixes_applied
-            if "hook" not in f.lower()
-            or "complexity" in f.lower()
-            or "type" in f.lower()
-        ]
+        hook_fixes = [fix for fix in fixes_applied if self._is_hook_related_fix(fix)]
         return bool(hook_fixes)
 
+    def _is_hook_related_fix(self, fix: str) -> bool:
+        """Check if a fix is related to hooks and should trigger hook verification."""
+        fix_lower = fix.lower()
+        return (
+            "hook" not in fix_lower or "complexity" in fix_lower or "type" in fix_lower
+        )
+
     async def _verify_hook_fixes(self, options: OptionsProtocol) -> bool:
         self.logger.info("Re-running comprehensive hooks to verify hook fixes")
         hook_success = self.phases.run_comprehensive_hooks_only(options)
@@ -1299,35 +1359,30 @@ class WorkflowPipeline:
         return issues
 
     def _parse_comprehensive_hook_errors(self, error_msg: str) -> list[Issue]:
-        issues: list[Issue] = []
         error_lower = error_msg.lower()
+        error_checkers = self._get_comprehensive_error_checkers()
 
-        complexity_issue = self._check_complexity_error(error_lower)
-        if complexity_issue:
-            issues.append(complexity_issue)
-
-        type_error_issue = self._check_type_error(error_lower)
-        if type_error_issue:
-            issues.append(type_error_issue)
-
-        security_issue = self._check_security_error(error_lower)
-        if security_issue:
-            issues.append(security_issue)
-
-        performance_issue = self._check_performance_error(error_lower)
-        if performance_issue:
-            issues.append(performance_issue)
-
-        dead_code_issue = self._check_dead_code_error(error_lower)
-        if dead_code_issue:
-            issues.append(dead_code_issue)
-
-        regex_issue = self._check_regex_validation_error(error_lower)
-        if regex_issue:
-            issues.append(regex_issue)
+        issues = []
+        for check_func in error_checkers:
+            issue = check_func(error_lower)
+            if issue:
+                issues.append(issue)
 
         return issues
 
+    def _get_comprehensive_error_checkers(
+        self,
+    ) -> list[t.Callable[[str], Issue | None]]:
+        """Get list of error checking functions for comprehensive hooks."""
+        return [
+            self._check_complexity_error,
+            self._check_type_error,
+            self._check_security_error,
+            self._check_performance_error,
+            self._check_dead_code_error,
+            self._check_regex_validation_error,
+        ]
+
     def _check_complexity_error(self, error_lower: str) -> Issue | None:
         if "complexipy" in error_lower or "c901" in error_lower:
             return Issue(
@@ -1426,24 +1481,66 @@ class WorkflowPipeline:
     def _classify_issue(self, issue_str: str) -> tuple[IssueType, Priority]:
         issue_lower = issue_str.lower()
 
-        if self._is_type_error(issue_lower):
-            return IssueType.TYPE_ERROR, Priority.HIGH
-        if self._is_security_issue(issue_lower):
-            return IssueType.SECURITY, Priority.HIGH
-        if self._is_complexity_issue(issue_lower):
-            return IssueType.COMPLEXITY, Priority.HIGH
-        if self._is_regex_validation_issue(issue_lower):
-            return IssueType.REGEX_VALIDATION, Priority.HIGH
-
-        if self._is_dead_code_issue(issue_lower):
-            return IssueType.DEAD_CODE, Priority.MEDIUM
-        if self._is_performance_issue(issue_lower):
-            return IssueType.PERFORMANCE, Priority.MEDIUM
-        if self._is_import_error(issue_lower):
-            return IssueType.IMPORT_ERROR, Priority.MEDIUM
+        # Check high priority issues first
+        high_priority_result = self._check_high_priority_issues(issue_lower)
+        if high_priority_result:
+            return high_priority_result
 
+        # Check medium priority issues
+        medium_priority_result = self._check_medium_priority_issues(issue_lower)
+        if medium_priority_result:
+            return medium_priority_result
+
+        # Default to formatting issue
         return IssueType.FORMATTING, Priority.MEDIUM
 
+    def _check_high_priority_issues(
+        self, issue_lower: str
+    ) -> tuple[IssueType, Priority] | None:
+        """Check for high priority issue types.
+
+        Args:
+            issue_lower: Lowercase issue string
+
+        Returns:
+            Tuple of issue type and priority if found, None otherwise
+        """
+        high_priority_checks = [
+            (self._is_type_error, IssueType.TYPE_ERROR),
+            (self._is_security_issue, IssueType.SECURITY),
+            (self._is_complexity_issue, IssueType.COMPLEXITY),
+            (self._is_regex_validation_issue, IssueType.REGEX_VALIDATION),
+        ]
+
+        for check_func, issue_type in high_priority_checks:
+            if check_func(issue_lower):
+                return issue_type, Priority.HIGH
+
+        return None
+
+    def _check_medium_priority_issues(
+        self, issue_lower: str
+    ) -> tuple[IssueType, Priority] | None:
+        """Check for medium priority issue types.
+
+        Args:
+            issue_lower: Lowercase issue string
+
+        Returns:
+            Tuple of issue type and priority if found, None otherwise
+        """
+        medium_priority_checks = [
+            (self._is_dead_code_issue, IssueType.DEAD_CODE),
+            (self._is_performance_issue, IssueType.PERFORMANCE),
+            (self._is_import_error, IssueType.IMPORT_ERROR),
+        ]
+
+        for check_func, issue_type in medium_priority_checks:
+            if check_func(issue_lower):
+                return issue_type, Priority.MEDIUM
+
+        return None
+
     def _is_type_error(self, issue_lower: str) -> bool:
         return any(
             keyword in issue_lower for keyword in ("type", "annotation", "pyright")
@@ -1512,44 +1609,77 @@ class WorkflowPipeline:
     async def _handle_security_gate_failure(
         self, options: OptionsProtocol, allow_ai_fixing: bool = False
     ) -> bool:
+        self._display_security_gate_failure_message()
+
+        if allow_ai_fixing:
+            return await self._attempt_ai_assisted_security_fix(options)
+        return self._handle_manual_security_fix()
+
+    def _display_security_gate_failure_message(self) -> None:
+        """Display initial security gate failure message."""
         self.console.print(
             "[red]🔒 SECURITY GATE: Critical security checks failed[/red]"
         )
 
-        if allow_ai_fixing:
-            self.console.print(
-                "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
-            )
-            self.console.print(
-                "[yellow]🤖 Attempting AI-assisted security issue resolution...[/yellow]"
-            )
+    async def _attempt_ai_assisted_security_fix(self, options: OptionsProtocol) -> bool:
+        """Attempt to fix security issues using AI assistance.
 
-            ai_fix_success = await self._run_ai_agent_fixing_phase(options)
-            if ai_fix_success:
-                try:
-                    security_still_blocks = self._check_security_critical_failures()
-                    if not security_still_blocks:
-                        self.console.print(
-                            "[green]✅ AI agents resolved security issues - publishing allowed[/green]"
-                        )
-                        return True
-                    else:
-                        self.console.print(
-                            "[red]🔒 Security issues persist after AI fixing - publishing still BLOCKED[/red]"
-                        )
-                        return False
-                except Exception as e:
-                    self.logger.warning(
-                        f"Security re-check failed: {e} - blocking publishing"
-                    )
-                    return False
-            return False
-        else:
-            self.console.print(
-                "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
-            )
+        Args:
+            options: Configuration options
+
+        Returns:
+            True if security issues were resolved, False otherwise
+        """
+        self._display_ai_fixing_messages()
+
+        ai_fix_success = await self._run_ai_agent_fixing_phase(options)
+        if ai_fix_success:
+            return self._verify_security_fix_success()
+
+        return False
+
+    def _display_ai_fixing_messages(self) -> None:
+        """Display messages about AI-assisted security fixing."""
+        self.console.print(
+            "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
+        )
+        self.console.print(
+            "[yellow]🤖 Attempting AI-assisted security issue resolution...[/yellow]"
+        )
+
+    def _verify_security_fix_success(self) -> bool:
+        """Verify that AI fixes resolved the security issues.
+
+        Returns:
+            True if security issues were resolved, False otherwise
+        """
+        try:
+            security_still_blocks = self._check_security_critical_failures()
+            if not security_still_blocks:
+                self.console.print(
+                    "[green]✅ AI agents resolved security issues - publishing allowed[/green]"
+                )
+                return True
+            else:
+                self.console.print(
+                    "[red]🔒 Security issues persist after AI fixing - publishing still BLOCKED[/red]"
+                )
+                return False
+        except Exception as e:
+            self.logger.warning(f"Security re-check failed: {e} - blocking publishing")
             return False
 
+    def _handle_manual_security_fix(self) -> bool:
+        """Handle security fix when AI assistance is not allowed.
+
+        Returns:
+            Always False since manual intervention is required
+        """
+        self.console.print(
+            "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
+        )
+        return False
+
     def _determine_ai_fixing_needed(
         self,
         testing_passed: bool,

crackerjack/documentation/reference_generator.py

@@ -485,44 +485,74 @@ class ReferenceGenerator:
         Returns:
             Enhanced commands with workflow info
         """
-        # Define common workflow patterns
-        workflow_patterns = {
+        workflow_patterns = self._get_workflow_patterns()
+
+        for command in commands.values():
+            self._assign_command_workflows(command, workflow_patterns)
+            self._add_ai_context_to_command(command)
+
+        return commands
+
+    def _get_workflow_patterns(self) -> dict[str, list[str]]:
+        """Get workflow patterns for command categorization.
+
+        Returns:
+            Dictionary mapping workflow names to pattern lists
+        """
+        return {
             "development": ["test", "format", "lint", "type-check"],
             "release": ["version", "build", "publish", "tag"],
             "maintenance": ["clean", "update", "optimize", "backup"],
             "monitoring": ["status", "health", "metrics", "logs"],
         }
 
-        for command in commands.values():
-            # Assign workflows based on command name patterns
-            for workflow, patterns in workflow_patterns.items():
-                if any(pattern in command.name for pattern in patterns):
-                    command.common_workflows.append(workflow)
-
-            # Add AI context based on command purpose
-            if "test" in command.name:
-                command.ai_context.update(
-                    {
-                        "purpose": "quality_assurance",
-                        "automation_level": "high",
-                        "ai_agent_compatible": True,
-                    }
-                )
-                command.success_patterns.append("All tests passed")
-                command.failure_patterns.append("Test failures detected")
-
-            elif "format" in command.name or "lint" in command.name:
-                command.ai_context.update(
-                    {
-                        "purpose": "code_quality",
-                        "automation_level": "high",
-                        "ai_agent_compatible": True,
-                    }
-                )
-                command.success_patterns.append("No formatting issues")
-                command.failure_patterns.append("Style violations found")
+    def _assign_command_workflows(
+        self, command: CommandInfo, workflow_patterns: dict[str, list[str]]
+    ) -> None:
+        """Assign workflows to a command based on name patterns.
 
-        return commands
+        Args:
+            command: Command to assign workflows to
+            workflow_patterns: Workflow patterns to match against
+        """
+        for workflow, patterns in workflow_patterns.items():
+            if any(pattern in command.name for pattern in patterns):
+                command.common_workflows.append(workflow)
+
+    def _add_ai_context_to_command(self, command: CommandInfo) -> None:
+        """Add AI context to a command based on its purpose.
+
+        Args:
+            command: Command to enhance with AI context
+        """
+        if "test" in command.name:
+            self._add_test_ai_context(command)
+        elif "format" in command.name or "lint" in command.name:
+            self._add_quality_ai_context(command)
+
+    def _add_test_ai_context(self, command: CommandInfo) -> None:
+        """Add AI context for test-related commands."""
+        command.ai_context.update(
+            {
+                "purpose": "quality_assurance",
+                "automation_level": "high",
+                "ai_agent_compatible": True,
+            }
+        )
+        command.success_patterns.append("All tests passed")
+        command.failure_patterns.append("Test failures detected")
+
+    def _add_quality_ai_context(self, command: CommandInfo) -> None:
+        """Add AI context for code quality commands."""
+        command.ai_context.update(
+            {
+                "purpose": "code_quality",
+                "automation_level": "high",
+                "ai_agent_compatible": True,
+            }
+        )
+        command.success_patterns.append("No formatting issues")
+        command.failure_patterns.append("Style violations found")
 
     def _categorize_commands(
         self, commands: dict[str, CommandInfo]
@@ -536,8 +566,18 @@ class ReferenceGenerator:
             Dictionary of category to command names
         """
         categories: dict[str, list[str]] = {}
+        category_patterns = self._get_category_patterns()
+
+        for command in commands.values():
+            category = self._determine_command_category(command, category_patterns)
+            command.category = category
+            self._add_command_to_category(categories, category, command.name)
+
+        return categories
 
-        category_patterns = {
+    def _get_category_patterns(self) -> dict[str, list[str]]:
+        """Get category patterns for command classification."""
+        return {
             "development": ["test", "format", "lint", "check", "run"],
             "server": ["server", "start", "stop", "restart", "monitor"],
             "release": ["version", "bump", "publish", "build", "tag"],
@@ -545,27 +585,22 @@ class ReferenceGenerator:
             "utilities": ["clean", "help", "info", "status"],
         }
 
-        for command in commands.values():
-            assigned = False
-
-            # Assign based on patterns
-            for category, patterns in category_patterns.items():
-                if any(pattern in command.name for pattern in patterns):
-                    command.category = category
-                    if category not in categories:
-                        categories[category] = []
-                    categories[category].append(command.name)
-                    assigned = True
-                    break
-
-            # Default category
-            if not assigned:
-                command.category = "general"
-                if "general" not in categories:
-                    categories["general"] = []
-                categories["general"].append(command.name)
-
-        return categories
+    def _determine_command_category(
+        self, command: CommandInfo, category_patterns: dict[str, list[str]]
+    ) -> str:
+        """Determine the category for a command based on patterns."""
+        for category, patterns in category_patterns.items():
+            if any(pattern in command.name for pattern in patterns):
+                return category
+        return "general"
+
+    def _add_command_to_category(
+        self, categories: dict[str, list[str]], category: str, command_name: str
+    ) -> None:
+        """Add command to the specified category."""
+        if category not in categories:
+            categories[category] = []
+        categories[category].append(command_name)
 
     def _generate_workflows(
         self, commands: dict[str, CommandInfo]
@@ -663,7 +698,9 @@ class ReferenceGenerator:
         """Render command categories for markdown."""
         category_lines = []
         for category, command_names in reference.categories.items():
-            category_section = self._render_markdown_category(category, reference.commands, command_names)
+            category_section = self._render_markdown_category(
+                category, reference.commands, command_names
+            )
             category_lines.extend(category_section)
         return category_lines
 
@@ -733,7 +770,9 @@ class ReferenceGenerator:
 
         # Add related commands section
         if command.related_commands:
-            related_lines = self._render_command_related_markdown(command.related_commands)
+            related_lines = self._render_command_related_markdown(
+                command.related_commands
+            )
             lines.extend(related_lines)
 
         return lines
@@ -813,9 +852,11 @@ class ReferenceGenerator:
     def _render_html(self, reference: CommandReference) -> str:
         """Render reference as HTML."""
         html_parts = [
-            self._render_html_header(reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")),
+            self._render_html_header(
+                reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")
+            ),
             self._render_html_commands(reference),
-            "</body></html>"
+            "</body></html>",
         ]
         return "".join(html_parts)
 
@@ -842,7 +883,9 @@ class ReferenceGenerator:
         """Render HTML commands by category."""
         html_parts = []
         for category, command_names in reference.categories.items():
-            category_html = self._render_html_category(category, reference.commands, command_names)
+            category_html = self._render_html_category(
+                category, reference.commands, command_names
+            )
             html_parts.append(category_html)
         return "".join(html_parts)
 
@@ -918,7 +961,9 @@ class ReferenceGenerator:
             "aliases": command.aliases,
         }
 
-    def _serialize_parameters(self, parameters: list[ParameterInfo]) -> list[dict[str, t.Any]]:
+    def _serialize_parameters(
+        self, parameters: list[ParameterInfo]
+    ) -> list[dict[str, t.Any]]:
         """Serialize parameters for JSON output."""
         return [self._serialize_parameter(param) for param in parameters]
 

crackerjack/dynamic_config.py

@@ -192,7 +192,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "stages": ["pre-push", "manual"],
             "args": ["-c", "pyproject.toml", "-r", "-ll"],
             "files": "^crackerjack/.*\\.py$",
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": None,
@@ -284,9 +284,9 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "tier": 3,
             "time_estimate": 0.1,
             "stages": ["pre-push", "manual"],
-            "args": ["crackerjack"],
+            "args": ["crackerjack", "--exclude", "tests"],
             "files": None,
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": "system",
@@ -338,9 +338,9 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "tier": 3,
             "time_estimate": 3.0,
             "stages": ["pre-push", "manual"],
-            "args": ["--ignore", "FURB184", "--ignore", "FURB120"],
+            "args": [],
             "files": "^crackerjack/.*\\.py$",
-            "exclude": r"^tests/.*\.py$",
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": None,
@@ -358,7 +358,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "stages": ["pre-push", "manual"],
             "args": ["--config-file", "mypy.ini", "./crackerjack"],
             "files": None,
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": "system",
@@ -544,7 +544,7 @@ class DynamicConfigGenerator:
         """Update hook configuration to use the detected package directory."""
         # Update skylos hook
         if hook["id"] == "skylos" and hook["args"]:
-            hook["args"] = [self.package_directory]
+            hook["args"] = [self.package_directory, "--exclude", "tests"]
 
         # Update zuban hook
         elif hook["id"] == "zuban" and hook["args"]:
@@ -566,12 +566,24 @@ class DynamicConfigGenerator:
                 "crackerjack", self.package_directory
             )
 
-        # Ensure hooks exclude src directories to avoid JavaScript conflicts
+        # Ensure hooks exclude src directories to avoid JavaScript conflicts and tests
         if hook["exclude"]:
+            # Add src exclusion if not present
             if "src/" not in hook["exclude"]:
                 hook["exclude"] = f"{hook['exclude']}|^src/"
         else:
-            hook["exclude"] = "^src/"
+            # If no exclusion, add both tests and src
+            if hook["id"] in (
+                "skylos",
+                "zuban",
+                "bandit",
+                "refurb",
+                "complexipy",
+                "pyright",
+            ):
+                hook["exclude"] = r"^tests/|^src/"
+            else:
+                hook["exclude"] = "^src/"
 
         return hook
 

crackerjack/interactive.py

@@ -24,7 +24,7 @@ class TaskStatus(Enum):
 
 
 @dataclass
-class WorkflowOptions:
+class InteractiveWorkflowOptions:
     clean: bool = False
     test: bool = False
     publish: str | None = None
@@ -35,7 +35,7 @@ class WorkflowOptions:
     dry_run: bool = False
 
     @classmethod
-    def from_args(cls, args: t.Any) -> "WorkflowOptions":
+    def from_args(cls, args: t.Any) -> "InteractiveWorkflowOptions":
         return cls(
             clean=getattr(args, "clean", False),
             test=getattr(args, "test", False),
@@ -399,7 +399,7 @@ class InteractiveCLI:
 
         self.logger = logging.getLogger("crackerjack.interactive.cli")
 
-    def create_dynamic_workflow(self, options: WorkflowOptions) -> None:
+    def create_dynamic_workflow(self, options: InteractiveWorkflowOptions) -> None:
         builder = WorkflowBuilder(self.console)
 
         workflow_steps = [
@@ -581,7 +581,7 @@ class InteractiveCLI:
             or last_task
         )
 
-    def run_interactive_workflow(self, options: WorkflowOptions) -> bool:
+    def run_interactive_workflow(self, options: InteractiveWorkflowOptions) -> bool:
         self.logger.info(
             f"Starting interactive workflow with options: {options.__dict__}",
         )
@@ -682,7 +682,9 @@ def launch_interactive_cli(version: str, options: t.Any = None) -> None:
     console.print()
 
     workflow_options = (
-        WorkflowOptions.from_args(options) if options else WorkflowOptions()
+        InteractiveWorkflowOptions.from_args(options)
+        if options
+        else InteractiveWorkflowOptions()
     )
     cli.create_dynamic_workflow(workflow_options)
     cli.run_interactive_workflow(workflow_options)

crackerjack/plugins/hooks.py

@@ -133,7 +133,7 @@ class CustomHookPlugin(HookPluginBase):
                 return HookResult(
                     name=hook_def.name,
                     status="failed",
-                    message="Hook command is None",
+                    issues_found=["Hook command is None"],
                     duration=0.0,
                 )
             cmd = hook_def.command.copy()

{crackerjack-0.37.9.dist-info → crackerjack-0.38.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.37.9
+Version: 0.38.0
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack
@@ -73,7 +73,7 @@ Description-Content-Type: text/markdown
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-![Coverage](https://img.shields.io/badge/coverage-17.6%25-red)
+![Coverage](https://img.shields.io/badge/coverage-37.1%25-red)
 
 ## 🎯 Purpose
 

{crackerjack-0.37.9.dist-info → crackerjack-0.38.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-crackerjack/__init__.py,sha256=k8_Ev_3fWdjFtGNSJdSOvyaSLW54y3j484d3a8k_Ob4,1396
+crackerjack/__init__.py,sha256=DajG9zHB8qBdgdiKMumrrssUbKeMXmtIQ3oOaSTb46Y,1426
 crackerjack/__main__.py,sha256=lE5ZDbAzI9TLCzMTxFGw23Dk1hP-MEhd1i_nNbi_Mag,52515
-crackerjack/api.py,sha256=sfKzCphsTMFCvdNizviPdYemwg0H8Oei_5C08LAuDvA,21538
+crackerjack/api.py,sha256=PyCRaZHvKWdu62_2O4t_HcEfKNBdqyrfPdonS_PNn4c,21495
 crackerjack/code_cleaner.py,sha256=M1zVaq31uW0nOkPneKR8kfR3892gyyVx0VhFgRaxsj4,44338
-crackerjack/dynamic_config.py,sha256=nwHVFCf84mokfzXhMo91-DD1ecEB6tXIgGBg0836auU,22017
+crackerjack/dynamic_config.py,sha256=4c8Fts9vyH8Tdon_47OFVT1iTBINSzSgB0WoeSvpzII,22418
 crackerjack/errors.py,sha256=yYbZ92kn_y6acEWgQvEPvozAYs2HT65uLwAXrtXxGsE,10049
-crackerjack/interactive.py,sha256=yjTnk0xWvDnZeCaB11TcRGxVLTXWPRnGBsekiMcyRvU,21317
+crackerjack/interactive.py,sha256=CYu53ySL2I1YCWRRRHmVEYQq3RQ0xDCXFTuPUAw6DTc,21399
 crackerjack/adapters/__init__.py,sha256=k-8ajMDL9DS9hV2FYOu694nmNQg3HkudJRuNcXmx8N4,451
 crackerjack/adapters/lsp_client.py,sha256=4kQ3T5JiWC7uc6kOjZuPdtUboseKSDjZpuKQpV74onc,10963
 crackerjack/adapters/rust_tool_adapter.py,sha256=ui_qMt_WIwInRvRCeT7MnIdp8eln7Fvp4hakXQiVnjg,5999
@@ -54,7 +54,7 @@ crackerjack/core/service_watchdog.py,sha256=Ttj1imOxvUea4Tkf5JO1e2dQtGIK7D-bX1xO
 crackerjack/core/session_coordinator.py,sha256=TgoGE9DfXe2x-OkH93Ld9dX9ROjx2_mZFkGXen-z5YI,15680
 crackerjack/core/timeout_manager.py,sha256=_sbEsfYDwWx7y0Pn89QCoAZ5DpWIbCdtR9qkG_Kqj5E,15013
 crackerjack/core/websocket_lifecycle.py,sha256=74kn6ugu6FLlDQhCNSPgqguCFwRoT1WFOvtl8G2OyFc,12860
-crackerjack/core/workflow_orchestrator.py,sha256=y_bYIZ2cn-DD8J1A9xkS9TawUJ8qdeirmB5HHrzTwg8,71867
+crackerjack/core/workflow_orchestrator.py,sha256=S7XiVdJEEKcHQF1_PL1IymDpx940le_z6ozG6EIpk-s,75876
 crackerjack/docs/INDEX.md,sha256=a6CGFEeL5DX_FRft_JFWd0nOxoBmCSSp-QHIC3B7ato,342
 crackerjack/docs/generated/api/API_REFERENCE.md,sha256=mWoqImZA7AhDvRqqF1MhUo70g_pnZr3NoBeZQRotqN8,155816
 crackerjack/docs/generated/api/CLI_REFERENCE.md,sha256=ikuG0hO5EjIiQlJtAUnvEuAhXDa-JHPULPXNNmUwvk4,2805
@@ -65,7 +65,7 @@ crackerjack/documentation/__init__.py,sha256=gGR--er5oTHhbwLKOHVlU2QgGmQtA0qUXf3
 crackerjack/documentation/ai_templates.py,sha256=GRBKB5bqWudh9MDLjo1b3vNiFAgpL62ezzRp_WxTews,21629
 crackerjack/documentation/dual_output_generator.py,sha256=w7rDthOnyFeRPQDWvYiR4aiScPxsHzkwjJ3blMwT9-w,28552
 crackerjack/documentation/mkdocs_integration.py,sha256=KqU2_9mA-rjP_VDrrfr6KTuPWtTlcvkInPxoH03LTC0,15657
-crackerjack/documentation/reference_generator.py,sha256=RezcoengHOnPJp988KB--EYcMfjJqPpWWFIvzvOMNCc,33094
+crackerjack/documentation/reference_generator.py,sha256=NGAIsC5bnjLBQkvEXPDU0pw8bQ5kYzbUUokhlXXFqrU,34520
 crackerjack/executors/__init__.py,sha256=HF-DmXvKN45uKKDdiMxOT9bYxuy1B-Z91BihOhkK5lg,322
 crackerjack/executors/async_hook_executor.py,sha256=FmKpiAxpZXKwvOWXnRQ73N-reDfX8NusESQ9a4HeacM,17620
 crackerjack/executors/cached_hook_executor.py,sha256=izwdW0B22EZcl_2_llmTIyq5oTcZDZTRL2G97ZwYiXg,11173
@@ -145,7 +145,7 @@ crackerjack/orchestration/execution_strategies.py,sha256=G34eYqd5fqKPgPcRScASS86
 crackerjack/orchestration/test_progress_streamer.py,sha256=Yu6uHuhoCvX6SZP0QNG3Yt8Q4s2tufEHr40o16QU98c,22541
 crackerjack/plugins/__init__.py,sha256=B7hy9b9amJVbYLHgIz8kgTI29j-vYxsUY_sZ5ISbXU0,386
 crackerjack/plugins/base.py,sha256=VFk-xNsgjSlmzJ_iPQALhkr7cguiOtEd3XSR9CcCPkc,5732
-crackerjack/plugins/hooks.py,sha256=IOnYYEB366HR0t09bV7G_F7wOf2D9vtMcEiR0PRfwiw,7574
+crackerjack/plugins/hooks.py,sha256=XagUpeehUwP_k4NnODnn0M1ycTe1F4uP1EMiFULUlKY,7581
 crackerjack/plugins/loader.py,sha256=9RmA5Lkizz5BADn-aJDGekISyL7C_O2Grr1tB6undHY,10814
 crackerjack/plugins/managers.py,sha256=3kQlxjvcHyHDgZIdr-JZBO1kqz2asqA4kf2XVAA1K6A,8824
 crackerjack/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -224,8 +224,8 @@ crackerjack/tools/validate_input_validator_patterns.py,sha256=NN7smYlXWrHLQXTb-8
 crackerjack/tools/validate_regex_patterns.py,sha256=J7GG9EP1fASpRIsG8qRPeiCSkdCwmk0sdo29GgoJ6w8,5863
 crackerjack/ui/__init__.py,sha256=eMb1OeTU-dSLICAACn0YdYB4Amdr8wHckjKfn0wOIZE,37
 crackerjack/ui/server_panels.py,sha256=F5IH6SNN06BaZQMsFx_D-OA286aojmaFPJ5kvvSRv_c,4232
-crackerjack-0.37.9.dist-info/METADATA,sha256=CCZxJnuN5szGZEggJFKNED1WCXd8B1EY7xHAaqL7E6M,37949
-crackerjack-0.37.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crackerjack-0.37.9.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
-crackerjack-0.37.9.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack-0.37.9.dist-info/RECORD,,
+crackerjack-0.38.0.dist-info/METADATA,sha256=eOtnsgHgSIJAR_hBiHx8bgF6maVsKm7LdATHCdtTu6A,37949
+crackerjack-0.38.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.38.0.dist-info/entry_points.txt,sha256=AJKNft0WXm9xoGUJ3Trl-iXHOWxRAYbagQiza3AILr4,57
+crackerjack-0.38.0.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.38.0.dist-info/RECORD,,