crackerjack 0.31.18__py3-none-any.whl → 0.33.0__py3-none-any.whl

crackerjack/agents/refactoring_agent.py

@@ -468,19 +468,16 @@ class RefactoringAgent(SubAgent):
 
     def _apply_enhanced_complexity_patterns(self, content: str) -> str:
         """Apply enhanced complexity reduction patterns using SAFE_PATTERNS."""
-        modified_content = content
-
-        # Extract nested conditions to helper methods
-        modified_content = self._extract_nested_conditions(modified_content)
-
-        # Replace complex boolean expressions with helper functions
-        modified_content = self._simplify_boolean_expressions(modified_content)
-
-        # Extract validation patterns to separate methods
-        modified_content = self._extract_validation_patterns(modified_content)
+        operations = [
+            self._extract_nested_conditions,
+            self._simplify_boolean_expressions,
+            self._extract_validation_patterns,
+            self._simplify_data_structures,
+        ]
 
-        # Break down large dictionary/list operations
-        modified_content = self._simplify_data_structures(modified_content)
+        modified_content = content
+        for operation in operations:
+            modified_content = operation(modified_content)
 
         return modified_content
 
@@ -897,13 +894,7 @@ class RefactoringAgent(SubAgent):
     def _remove_dead_code_items(self, content: str, analysis: dict[str, t.Any]) -> str:
         """Enhanced removal of dead code items from content."""
         lines = content.split("\n")
-        lines_to_remove = self._find_lines_to_remove(lines, analysis)
-
-        # Also remove unreachable code blocks
-        lines_to_remove.update(self._find_unreachable_lines(lines, analysis))
-
-        # Remove redundant code patterns
-        lines_to_remove.update(self._find_redundant_lines(lines, analysis))
+        lines_to_remove = self._collect_all_removable_lines(lines, analysis)
 
         filtered_lines = [
             line for i, line in enumerate(lines) if i not in lines_to_remove
@@ -911,6 +902,22 @@ class RefactoringAgent(SubAgent):
 
         return "\n".join(filtered_lines)
 
+    def _collect_all_removable_lines(
+        self, lines: list[str], analysis: dict[str, t.Any]
+    ) -> set[int]:
+        """Collect all line indices that should be removed."""
+        removal_functions = [
+            lambda: self._find_lines_to_remove(lines, analysis),
+            lambda: self._find_unreachable_lines(lines, analysis),
+            lambda: self._find_redundant_lines(lines, analysis),
+        ]
+
+        lines_to_remove: set[int] = set()
+        for removal_func in removal_functions:
+            lines_to_remove.update(removal_func())
+
+        return lines_to_remove
+
     def _find_unreachable_lines(
         self, lines: list[str], analysis: dict[str, t.Any]
     ) -> set[int]:
@@ -933,21 +940,30 @@ class RefactoringAgent(SubAgent):
         lines_to_remove: set[int] = set()
 
         # Look for empty except blocks
-        for i, line in enumerate(lines):
-            stripped = line.strip()
-            if stripped == "except:" or stripped.startswith("except "):
-                # Check if next non-empty line is just 'pass'
-                for j in range(i + 1, min(i + 5, len(lines))):
-                    next_line = lines[j].strip()
-                    if not next_line:
-                        continue
-                    if next_line == "pass":
-                        lines_to_remove.add(j)
-                        break
-                    break
+        for i in range(len(lines)):
+            if self._is_empty_except_block(lines, i):
+                empty_pass_idx = self._find_empty_pass_line(lines, i)
+                if empty_pass_idx is not None:
+                    lines_to_remove.add(empty_pass_idx)
 
         return lines_to_remove
 
+    def _is_empty_except_block(self, lines: list[str], line_idx: int) -> bool:
+        """Check if line is an empty except block."""
+        stripped = lines[line_idx].strip()
+        return stripped == "except:" or stripped.startswith("except ")
+
+    def _find_empty_pass_line(self, lines: list[str], except_idx: int) -> int | None:
+        """Find the pass line in an empty except block."""
+        for j in range(except_idx + 1, min(except_idx + 5, len(lines))):
+            next_line = lines[j].strip()
+            if not next_line:
+                continue
+            if next_line == "pass":
+                return j
+            break
+        return None
+
     def _extract_function_content(
         self, lines: list[str], func_info: dict[str, t.Any]
     ) -> str:
@@ -968,30 +984,35 @@ class RefactoringAgent(SubAgent):
     ) -> str:
         """Apply function extraction by replacing original with calls to helpers."""
         lines = content.split("\n")
-        validation_result = self._validate_extraction_params(
-            lines, func_info, extracted_helpers
-        )
-        if validation_result:
-            return validation_result
 
-        new_lines = self._replace_function_with_calls(
-            lines, func_info, extracted_helpers
-        )
-        return self._add_helper_definitions(new_lines, func_info, extracted_helpers)
+        if not self._is_extraction_valid(lines, func_info, extracted_helpers):
+            return "\n".join(lines)
+
+        return self._perform_extraction(lines, func_info, extracted_helpers)
 
-    def _validate_extraction_params(
+    def _is_extraction_valid(
         self,
         lines: list[str],
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
-    ) -> str | None:
-        """Validate parameters for function extraction."""
+    ) -> bool:
+        """Check if extraction parameters are valid."""
         start_line = func_info["line_start"] - 1
         end_line = func_info.get("line_end", len(lines)) - 1
 
-        if not extracted_helpers or start_line < 0 or end_line >= len(lines):
-            return "\n".join(lines)
-        return None
+        return bool(extracted_helpers) and start_line >= 0 and end_line < len(lines)
+
+    def _perform_extraction(
+        self,
+        lines: list[str],
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> str:
+        """Perform the actual function extraction."""
+        new_lines = self._replace_function_with_calls(
+            lines, func_info, extracted_helpers
+        )
+        return self._add_helper_definitions(new_lines, func_info, extracted_helpers)
 
     def _replace_function_with_calls(
         self,

crackerjack/cli/handlers.py

@@ -8,19 +8,19 @@ from rich.console import Console
 from .options import Options
 
 
-def setup_ai_agent_env(ai_agent: bool, verbose: bool = False) -> None:
-    # Set debug environment variable if verbose is enabled
-    if verbose:
+def setup_ai_agent_env(ai_agent: bool, debug_mode: bool = False) -> None:
+    # Only set debug environment variable if debug mode is explicitly enabled
+    if debug_mode:
         os.environ["CRACKERJACK_DEBUG"] = "1"
 
     if ai_agent:
         os.environ["AI_AGENT"] = "1"
-        os.environ["AI_AGENT_DEBUG"] = "1"
-
-        if verbose:
+        # Only enable AI agent debug if debug mode is explicitly requested
+        if debug_mode:
+            os.environ["AI_AGENT_DEBUG"] = "1"
             os.environ["AI_AGENT_VERBOSE"] = "1"
 
-        if verbose:
+            # Show debug configuration when debug mode is enabled
             console = Console()
             console.print(
                 "[bold cyan]🐛 AI Agent Debug Mode Configuration: [/ bold cyan]",

crackerjack/config/hooks.py

@@ -14,6 +14,17 @@ class RetryPolicy(Enum):
     ALL_HOOKS = "all_hooks"
 
 
+class SecurityLevel(Enum):
+    """Security classification for hooks - determines bypass behavior."""
+
+    CRITICAL = (
+        "critical"  # Cannot be bypassed for publishing (security scans, type safety)
+    )
+    HIGH = "high"  # Important but can be bypassed with warning
+    MEDIUM = "medium"  # Standard checks, bypassable
+    LOW = "low"  # Formatting/style, always bypassable
+
+
 @dataclass
 class HookDefinition:
     name: str
@@ -24,6 +35,7 @@ class HookDefinition:
     is_formatting: bool = False
     manual_stage: bool = False
     config_path: Path | None = None
+    security_level: SecurityLevel = SecurityLevel.MEDIUM  # Default security level
 
     def get_command(self) -> list[str]:
         # Use direct pre-commit execution (pre-commit manages its own environments)
@@ -66,60 +78,72 @@ FAST_HOOKS = [
         is_formatting=True,  # Treat as formatting for autofix purposes
         timeout=30,
         retry_on_failure=True,  # Enable retries for autofix
+        security_level=SecurityLevel.HIGH,  # Regex vulnerabilities are security-relevant
     ),
     HookDefinition(
         name="trailing-whitespace",
         command=[],  # Dynamically built by get_command()
         is_formatting=True,
         retry_on_failure=True,
+        security_level=SecurityLevel.LOW,  # Whitespace formatting, always bypassable
     ),
     HookDefinition(
         name="end-of-file-fixer",
         command=[],  # Dynamically built by get_command()
         is_formatting=True,
         retry_on_failure=True,
+        security_level=SecurityLevel.LOW,  # File formatting, always bypassable
     ),
     HookDefinition(
         name="check-yaml",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.MEDIUM,  # File validation, standard check
     ),
     HookDefinition(
         name="check-toml",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.MEDIUM,  # File validation, standard check
     ),
     HookDefinition(
         name="check-added-large-files",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.HIGH,  # Large files can be security risk
     ),
     HookDefinition(
         name="uv-lock",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.HIGH,  # Dependency locking is security-relevant
     ),
     HookDefinition(
         name="gitleaks",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.CRITICAL,  # Secret detection is critical for security
     ),
     HookDefinition(
         name="codespell",
         command=[],  # Dynamically built by get_command()
+        security_level=SecurityLevel.LOW,  # Spelling, not security-critical
     ),
     HookDefinition(
         name="ruff-check",
         command=[],  # Dynamically built by get_command()
         is_formatting=True,  # Treat as formatting for autofix purposes
         retry_on_failure=True,  # Enable retries for autofix
+        security_level=SecurityLevel.MEDIUM,  # Code quality, not directly security
     ),
     HookDefinition(
         name="ruff-format",
         command=[],  # Dynamically built by get_command()
         is_formatting=True,
         retry_on_failure=True,
+        security_level=SecurityLevel.LOW,  # Pure formatting, always bypassable
     ),
     HookDefinition(
         name="mdformat",
         command=[],  # Dynamically built by get_command()
         is_formatting=True,
         retry_on_failure=True,
+        security_level=SecurityLevel.LOW,  # Documentation formatting, always bypassable
     ),
 ]
 
@@ -127,37 +151,42 @@ COMPREHENSIVE_HOOKS = [
     HookDefinition(
         name="pyright",
         command=[],  # Dynamically built by get_command()
-        timeout=120,
+        timeout=300,  # Fixed: Use 300s to match pytest config
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.CRITICAL,  # Type safety prevents security holes
     ),
     HookDefinition(
         name="bandit",
         command=[],  # Dynamically built by get_command()
-        timeout=120,
+        timeout=300,  # Fixed: Use 300s to match pytest config
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.CRITICAL,  # Security vulnerability scanning
     ),
     HookDefinition(
         name="vulture",
         command=[],  # Dynamically built by get_command()
-        timeout=120,
+        timeout=300,  # Fixed: Use 300s to match pytest config
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.MEDIUM,  # Dead code removal, not critical for security
     ),
     HookDefinition(
         name="refurb",
         command=[],  # Dynamically built by get_command()
-        timeout=120,
+        timeout=300,  # Fixed: Use 300s to match pytest config
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.MEDIUM,  # Code quality, not directly security
     ),
     HookDefinition(
         name="creosote",
         command=[],  # Dynamically built by get_command()
-        timeout=120,
+        timeout=300,  # Fixed: Use 300s to match pytest config
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.HIGH,  # Dependency analysis, security-relevant
     ),
     HookDefinition(
         name="complexipy",
@@ -165,6 +194,7 @@ COMPREHENSIVE_HOOKS = [
         timeout=60,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
+        security_level=SecurityLevel.MEDIUM,  # Complexity analysis, not directly security
     ),
 ]
 
@@ -179,7 +209,7 @@ FAST_STRATEGY = HookStrategy(
 COMPREHENSIVE_STRATEGY = HookStrategy(
     name="comprehensive",
     hooks=COMPREHENSIVE_HOOKS,
-    timeout=120,
+    timeout=300,  # Fixed: Use 300s to match pytest config
     retry_policy=RetryPolicy.NONE,
 )
 

crackerjack/core/async_workflow_orchestrator.py

@@ -676,8 +676,8 @@ class AsyncWorkflowOrchestrator:
         session_id = getattr(self, "web_job_id", None) or str(int(time.time()))[:8]
         debug_log_file = log_manager.create_debug_log_file(session_id)
 
-        # Set log level based on verbosity - DEBUG only in verbose or debug mode
-        log_level = "DEBUG" if (self.verbose or self.debug) else "INFO"
+        # Set log level based on debug flag only - verbose should not enable DEBUG logs
+        log_level = "DEBUG" if self.debug else "INFO"
         setup_structured_logging(
             level=log_level, json_output=False, log_file=debug_log_file
         )

crackerjack/core/enhanced_container.py

@@ -11,11 +11,16 @@ from rich.console import Console
 
 from crackerjack.models.protocols import (
     ConfigMergeServiceProtocol,
+    ConfigurationServiceProtocol,
+    CoverageRatchetProtocol,
     FileSystemInterface,
     GitInterface,
     HookManager,
+    InitializationServiceProtocol,
     PublishManager,
+    SecurityServiceProtocol,
     TestManagerProtocol,
+    UnifiedConfigurationServiceProtocol,
 )
 from crackerjack.services.logging import get_logger
 
@@ -470,17 +475,79 @@ class ServiceCollectionBuilder:
 
         return self
 
+    def add_service_protocols(self) -> "ServiceCollectionBuilder":
+        """Add registrations for service protocols that don't have explicit builders."""
+        console = self.console or Console(force_terminal=True)
+        pkg_path = self.pkg_path or Path.cwd()
+
+        # Register CoverageRatchetProtocol
+        def create_coverage_ratchet() -> CoverageRatchetProtocol:
+            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+            return CoverageRatchetService(pkg_path, console)
+
+        self.container.register_transient(
+            CoverageRatchetProtocol,
+            factory=create_coverage_ratchet,
+        )
+
+        # Register ConfigurationServiceProtocol
+        def create_configuration_service() -> ConfigurationServiceProtocol:
+            from crackerjack.services.config import ConfigurationService
+
+            return ConfigurationService(console=console, pkg_path=pkg_path)
+
+        self.container.register_transient(
+            ConfigurationServiceProtocol,
+            factory=create_configuration_service,
+        )
+
+        # Register SecurityServiceProtocol
+        def create_security_service() -> SecurityServiceProtocol:
+            from crackerjack.services.security import SecurityService
+
+            return SecurityService()
+
+        self.container.register_transient(
+            SecurityServiceProtocol,
+            factory=create_security_service,
+        )
+
+        # Register InitializationServiceProtocol
+        def create_initialization_service() -> InitializationServiceProtocol:
+            from crackerjack.services.filesystem import FileSystemService
+            from crackerjack.services.git import GitService
+            from crackerjack.services.initialization import InitializationService
+
+            filesystem = FileSystemService()
+            git_service = GitService(console, pkg_path)
+            return InitializationService(console, filesystem, git_service, pkg_path)
+
+        self.container.register_transient(
+            InitializationServiceProtocol,
+            factory=create_initialization_service,
+        )
+
+        return self
+
     def add_configuration_services(self) -> "ServiceCollectionBuilder":
         console = self.console or Console(force_terminal=True)
         pkg_path = self.pkg_path or Path.cwd()
 
         from crackerjack.services.unified_config import UnifiedConfigurationService
 
+        # Register concrete class for backwards compatibility
         self.container.register_singleton(
             UnifiedConfigurationService,
             factory=lambda: UnifiedConfigurationService(console, pkg_path),
         )
 
+        # Register protocol interface
+        self.container.register_singleton(
+            UnifiedConfigurationServiceProtocol,
+            factory=lambda: self.container.get(UnifiedConfigurationService),
+        )
+
         # Register ConfigMergeService for smart configuration merging
         from crackerjack.services.config_merge import ConfigMergeService