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

crackerjack/config/hooks.py

@@ -15,14 +15,10 @@ class RetryPolicy(Enum):
 
 
 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
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
 
 
 @dataclass
@@ -35,14 +31,12 @@ class HookDefinition:
     is_formatting: bool = False
     manual_stage: bool = False
     config_path: Path | None = None
-    security_level: SecurityLevel = SecurityLevel.MEDIUM  # Default security level
+    security_level: SecurityLevel = SecurityLevel.MEDIUM
 
     def get_command(self) -> list[str]:
-        # Use direct pre-commit execution (pre-commit manages its own environments)
         import shutil
         from pathlib import Path
 
-        # Find pre-commit executable - prefer project venv, fallback to system
         pre_commit_path = None
         current_dir = Path.cwd()
         project_pre_commit = current_dir / ".venv" / "bin" / "pre-commit"
@@ -51,7 +45,6 @@ class HookDefinition:
         else:
             pre_commit_path = shutil.which("pre-commit") or "pre-commit"
 
-        # Build command for direct pre-commit execution
         cmd = [pre_commit_path, "run"]
         if self.config_path:
             cmd.extend(["-c", str(self.config_path)])
@@ -74,127 +67,127 @@ class HookStrategy:
 FAST_HOOKS = [
     HookDefinition(
         name="validate-regex-patterns",
-        command=[],  # Dynamically built by get_command()
-        is_formatting=True,  # Treat as formatting for autofix purposes
+        command=[],
+        is_formatting=True,
         timeout=30,
-        retry_on_failure=True,  # Enable retries for autofix
-        security_level=SecurityLevel.HIGH,  # Regex vulnerabilities are security-relevant
+        retry_on_failure=True,
+        security_level=SecurityLevel.HIGH,
     ),
     HookDefinition(
         name="trailing-whitespace",
-        command=[],  # Dynamically built by get_command()
+        command=[],
         is_formatting=True,
         retry_on_failure=True,
-        security_level=SecurityLevel.LOW,  # Whitespace formatting, always bypassable
+        security_level=SecurityLevel.LOW,
     ),
     HookDefinition(
         name="end-of-file-fixer",
-        command=[],  # Dynamically built by get_command()
+        command=[],
         is_formatting=True,
         retry_on_failure=True,
-        security_level=SecurityLevel.LOW,  # File formatting, always bypassable
+        security_level=SecurityLevel.LOW,
     ),
     HookDefinition(
         name="check-yaml",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.MEDIUM,  # File validation, standard check
+        command=[],
+        security_level=SecurityLevel.MEDIUM,
     ),
     HookDefinition(
         name="check-toml",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.MEDIUM,  # File validation, standard check
+        command=[],
+        security_level=SecurityLevel.MEDIUM,
     ),
     HookDefinition(
         name="check-added-large-files",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.HIGH,  # Large files can be security risk
+        command=[],
+        security_level=SecurityLevel.HIGH,
     ),
     HookDefinition(
         name="uv-lock",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.HIGH,  # Dependency locking is security-relevant
+        command=[],
+        security_level=SecurityLevel.HIGH,
     ),
     HookDefinition(
         name="gitleaks",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.CRITICAL,  # Secret detection is critical for security
+        command=[],
+        security_level=SecurityLevel.CRITICAL,
     ),
     HookDefinition(
         name="codespell",
-        command=[],  # Dynamically built by get_command()
-        security_level=SecurityLevel.LOW,  # Spelling, not security-critical
+        command=[],
+        security_level=SecurityLevel.LOW,
     ),
     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
+        command=[],
+        is_formatting=True,
+        retry_on_failure=True,
+        security_level=SecurityLevel.MEDIUM,
     ),
     HookDefinition(
         name="ruff-format",
-        command=[],  # Dynamically built by get_command()
+        command=[],
         is_formatting=True,
         retry_on_failure=True,
-        security_level=SecurityLevel.LOW,  # Pure formatting, always bypassable
+        security_level=SecurityLevel.LOW,
     ),
     HookDefinition(
         name="mdformat",
-        command=[],  # Dynamically built by get_command()
+        command=[],
         is_formatting=True,
         retry_on_failure=True,
-        security_level=SecurityLevel.LOW,  # Documentation formatting, always bypassable
+        security_level=SecurityLevel.LOW,
     ),
 ]
 
 COMPREHENSIVE_HOOKS = [
     HookDefinition(
-        name="pyright",
-        command=[],  # Dynamically built by get_command()
-        timeout=300,  # Fixed: Use 300s to match pytest config
+        name="zuban",
+        command=[],
+        timeout=30,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.CRITICAL,  # Type safety prevents security holes
+        security_level=SecurityLevel.CRITICAL,
     ),
     HookDefinition(
         name="bandit",
-        command=[],  # Dynamically built by get_command()
-        timeout=300,  # Fixed: Use 300s to match pytest config
+        command=[],
+        timeout=300,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.CRITICAL,  # Security vulnerability scanning
+        security_level=SecurityLevel.CRITICAL,
     ),
     HookDefinition(
-        name="vulture",
-        command=[],  # Dynamically built by get_command()
-        timeout=300,  # Fixed: Use 300s to match pytest config
+        name="skylos",
+        command=[],
+        timeout=30,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.MEDIUM,  # Dead code removal, not critical for security
+        security_level=SecurityLevel.MEDIUM,
     ),
     HookDefinition(
         name="refurb",
-        command=[],  # Dynamically built by get_command()
-        timeout=300,  # Fixed: Use 300s to match pytest config
+        command=[],
+        timeout=300,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.MEDIUM,  # Code quality, not directly security
+        security_level=SecurityLevel.MEDIUM,
     ),
     HookDefinition(
         name="creosote",
-        command=[],  # Dynamically built by get_command()
-        timeout=300,  # Fixed: Use 300s to match pytest config
+        command=[],
+        timeout=300,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.HIGH,  # Dependency analysis, security-relevant
+        security_level=SecurityLevel.HIGH,
     ),
     HookDefinition(
         name="complexipy",
-        command=[],  # Dynamically built by get_command()
+        command=[],
         timeout=60,
         stage=HookStage.COMPREHENSIVE,
         manual_stage=True,
-        security_level=SecurityLevel.MEDIUM,  # Complexity analysis, not directly security
+        security_level=SecurityLevel.MEDIUM,
     ),
 ]
 
@@ -209,7 +202,7 @@ FAST_STRATEGY = HookStrategy(
 COMPREHENSIVE_STRATEGY = HookStrategy(
     name="comprehensive",
     hooks=COMPREHENSIVE_HOOKS,
-    timeout=300,  # Fixed: Use 300s to match pytest config
+    timeout=300,
     retry_policy=RetryPolicy.NONE,
 )
 
@@ -223,5 +216,3 @@ class HookConfigLoader:
             return COMPREHENSIVE_STRATEGY
         msg = f"Unknown hook strategy: {name}"
         raise ValueError(msg)
-
-    # Removed unused method: get_all_strategies

crackerjack/core/async_workflow_orchestrator.py

@@ -84,18 +84,15 @@ class AsyncWorkflowPipeline:
         return success
 
     async def _cleanup_active_tasks(self) -> None:
-        """Clean up all active tasks."""
         if not self._active_tasks:
             return
 
         self.logger.info(f"Cleaning up {len(self._active_tasks)} active tasks")
 
-        # Cancel all active tasks
         for task in self._active_tasks:
             if not task.done():
                 task.cancel()
 
-        # Wait for tasks to complete with timeout
         if self._active_tasks:
             try:
                 await asyncio.wait_for(
@@ -111,17 +108,19 @@ class AsyncWorkflowPipeline:
         if not options.clean:
             return True
 
-        return await self.timeout_manager.with_timeout(
+        result = await self.timeout_manager.with_timeout(
             "file_operations",
-            asyncio.to_thread(self.phases.run_cleaning_phase, options),
+            asyncio.to_thread(self.phases.run_cleaning_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.RETRY_WITH_BACKOFF,
         )
+        return bool(result)
 
     async def _execute_quality_phase_async(self, options: OptionsProtocol) -> bool:
         if hasattr(options, "fast") and options.fast:
             return await self._run_fast_hooks_async(options)
         if hasattr(options, "comp") and options.comp:
             return await self._run_comprehensive_hooks_async(options)
+        print(f"DEBUG: options.test = {options.test}")
         if options.test:
             return await self._execute_test_workflow_async(options)
         return await self._execute_standard_hooks_workflow_async(options)
@@ -129,21 +128,17 @@ class AsyncWorkflowPipeline:
     async def _execute_test_workflow_async(self, options: OptionsProtocol) -> bool:
         overall_success = True
 
-        # Fast hooks with timeout
         if not await self._run_fast_hooks_async(options):
             overall_success = False
             self.session.fail_task("workflow", "Fast hooks failed")
             return False
 
-        # Run tests and comprehensive hooks in parallel
         try:
             test_task, hooks_task = self._create_parallel_tasks(options)
             done, pending = await self._execute_parallel_tasks(test_task, hooks_task)
 
-            # Cancel any pending tasks
             await self._cleanup_pending_tasks(pending)
 
-            # Process and validate results
             test_success, hooks_success = await self._process_task_results(
                 done, test_task, hooks_task
             )
@@ -160,7 +155,6 @@ class AsyncWorkflowPipeline:
     def _create_parallel_tasks(
         self, options: OptionsProtocol
     ) -> tuple[asyncio.Task[bool], asyncio.Task[bool]]:
-        """Create test and hooks tasks with timeout handling."""
         test_task = asyncio.create_task(
             self.timeout_manager.with_timeout(
                 "test_execution",
@@ -180,11 +174,10 @@ class AsyncWorkflowPipeline:
     async def _execute_parallel_tasks(
         self, test_task: asyncio.Task[bool], hooks_task: asyncio.Task[bool]
     ) -> tuple[set[asyncio.Task[bool]], set[asyncio.Task[bool]]]:
-        """Execute tasks in parallel with combined timeout."""
         combined_timeout = (
             self.timeout_manager.get_timeout("test_execution")
             + self.timeout_manager.get_timeout("comprehensive_hooks")
-            + 60  # Extra buffer
+            + 60
         )
 
         done, pending = await asyncio.wait(
@@ -196,7 +189,6 @@ class AsyncWorkflowPipeline:
         return done, pending
 
     async def _cleanup_pending_tasks(self, pending: set[asyncio.Task[t.Any]]) -> None:
-        """Clean up any pending tasks."""
         for task in pending:
             task.cancel()
             try:
@@ -210,7 +202,6 @@ class AsyncWorkflowPipeline:
         test_task: asyncio.Task[bool],
         hooks_task: asyncio.Task[bool],
     ) -> tuple[bool, bool]:
-        """Process results from completed tasks."""
         test_success = hooks_success = False
 
         for task in done:
@@ -232,7 +223,6 @@ class AsyncWorkflowPipeline:
     def _validate_workflow_results(
         self, test_success: bool, hooks_success: bool, overall_success: bool
     ) -> bool:
-        """Validate workflow results and handle failures."""
         if not test_success:
             overall_success = False
             self.session.fail_task("workflow", "Testing failed")
@@ -261,7 +251,6 @@ class AsyncWorkflowPipeline:
         timeout: float = 300.0,
         task_name: str = "workflow_task",
     ) -> asyncio.Task[t.Any]:
-        """Create a managed task with automatic cleanup."""
         task = asyncio.create_task(coro, name=task_name)
 
         if self.resource_context:
@@ -271,32 +260,36 @@ class AsyncWorkflowPipeline:
         return task
 
     async def _run_fast_hooks_async(self, options: OptionsProtocol) -> bool:
-        return await self.timeout_manager.with_timeout(
+        result = await self.timeout_manager.with_timeout(
             "fast_hooks",
-            asyncio.to_thread(self.phases.run_fast_hooks_only, options),
+            asyncio.to_thread(self.phases.run_fast_hooks_only, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.RETRY_WITH_BACKOFF,
         )
+        return bool(result)
 
     async def _run_comprehensive_hooks_async(self, options: OptionsProtocol) -> bool:
-        return await self.timeout_manager.with_timeout(
+        result = await self.timeout_manager.with_timeout(
             "comprehensive_hooks",
-            asyncio.to_thread(self.phases.run_comprehensive_hooks_only, options),
+            asyncio.to_thread(self.phases.run_comprehensive_hooks_only, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
+        return bool(result)
 
     async def _run_hooks_phase_async(self, options: OptionsProtocol) -> bool:
-        return await self.timeout_manager.with_timeout(
+        result = await self.timeout_manager.with_timeout(
             "comprehensive_hooks",
-            asyncio.to_thread(self.phases.run_hooks_phase, options),
+            asyncio.to_thread(self.phases.run_hooks_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
+        return bool(result)
 
     async def _run_testing_phase_async(self, options: OptionsProtocol) -> bool:
-        return await self.timeout_manager.with_timeout(
+        result = await self.timeout_manager.with_timeout(
             "test_execution",
-            asyncio.to_thread(self.phases.run_testing_phase, options),
+            asyncio.to_thread(self.phases.run_testing_phase, options),  # type: ignore[arg-type]
             strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
         )
+        return bool(result)
 
     async def _execute_ai_agent_workflow_async(
         self, options: OptionsProtocol, max_iterations: int = 10
@@ -326,7 +319,6 @@ class AsyncWorkflowPipeline:
             self.console.print(f"\n🔄 Iteration {iteration}/{max_iterations}")
 
             try:
-                # Each iteration has its own timeout
                 iteration_result = await self.timeout_manager.with_timeout(
                     "workflow_iteration",
                     self._execute_single_iteration(options, iteration),
@@ -342,7 +334,7 @@ class AsyncWorkflowPipeline:
             except Exception as e:
                 self.logger.error(f"Iteration {iteration} failed with error: {e}")
                 self.console.print(f"⚠️ Iteration {iteration} failed: {e}")
-                # Continue to next iteration unless it's a critical error
+
                 if iteration == max_iterations:
                     return False
 
@@ -419,7 +411,7 @@ class AsyncWorkflowPipeline:
 
         from crackerjack.agents.base import Issue, IssueType, Priority
 
-        match = re.search(  # REGEX OK: parsing structured refurb tool output
+        match = re.search(
             r"refurb: \s *(.+?): (\d +): (\d +)\s +\[(\w +)\]: \s *(.+)", issue
         )
         if match:
@@ -515,7 +507,7 @@ class AsyncWorkflowPipeline:
         try:
             hook_results = await self.timeout_manager.with_timeout(
                 "comprehensive_hooks",
-                asyncio.to_thread(self.phases.hook_manager.run_comprehensive_hooks),
+                asyncio.to_thread(self.phases.hook_manager.run_comprehensive_hooks),  # type: ignore[arg-type]
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             )
 
@@ -550,11 +542,12 @@ class AsyncWorkflowPipeline:
         )
 
         try:
-            return await self.timeout_manager.with_timeout(
+            result = await self.timeout_manager.with_timeout(
                 "ai_agent_processing",
                 self._execute_ai_fix_workflow(test_issues, hook_issues, iteration),
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             )
+            return bool(result)
         except Exception as e:
             return self._handle_ai_fix_error(e)
 
@@ -569,7 +562,6 @@ class AsyncWorkflowPipeline:
 
         coordinator = self._create_agent_coordinator()
 
-        # Apply timeout to AI coordinator processing
         fix_result = await self.timeout_manager.with_timeout(
             "ai_agent_processing",
             coordinator.handle_issues(structured_issues),
@@ -577,9 +569,9 @@ class AsyncWorkflowPipeline:
         )
 
         self._report_fix_results(fix_result, iteration)
-        return fix_result.success
+        return bool(fix_result.success if fix_result else False)
 
-    def _create_agent_coordinator(self):
+    def _create_agent_coordinator(self) -> t.Any:
         from crackerjack.agents.base import AgentContext
         from crackerjack.agents.coordinator import AgentCoordinator
 
@@ -626,7 +618,6 @@ class AsyncWorkflowOrchestrator:
         self.verbose = verbose
         self.debug = debug
 
-        # Initialize logging first so container creation respects log levels
         self._initialize_logging()
 
         from crackerjack.models.protocols import (
@@ -676,7 +667,6 @@ 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 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/autofix_coordinator.py

@@ -11,8 +11,7 @@ class AutofixCoordinator:
         self.console = console
         self.pkg_path = pkg_path
         self.logger = get_logger("crackerjack.autofix")
-        # For testing purposes, we need to set a name attribute
-        # We use setattr to avoid type checker issues since BoundLogger doesn't have a name attribute
+
         setattr(self.logger, "name", "crackerjack.autofix")
 
     def apply_autofix_for_hooks(self, mode: str, hook_results: list[object]) -> bool:
@@ -62,11 +61,9 @@ class AutofixCoordinator:
 
         hook_specific_fixes = self._get_hook_specific_fixes(failed_hooks)
 
-        # Run fast fixes first
         if not self._execute_fast_fixes():
             return False
 
-        # Apply hook-specific fixes
         all_successful = True
         for cmd, description in hook_specific_fixes:
             if not self._run_fix_command(cmd, description):
@@ -156,19 +153,16 @@ class AutofixCoordinator:
             "removed",
         ]
 
-        # Handle case where result might be a Mock object in tests
         if hasattr(result, "stdout") and hasattr(result, "stderr"):
-            # Handle the case where stdout/stderr might be Mock objects
             stdout = getattr(result, "stdout", "") or ""
             stderr = getattr(result, "stderr", "") or ""
-            # If they're Mock objects, convert to string
+
             if not isinstance(stdout, str):
                 stdout = str(stdout)
             if not isinstance(stderr, str):
                 stderr = str(stderr)
             output = stdout + stderr
         else:
-            # For test mocks or other objects
             output = str(result)
 
         output_lower = output.lower()
@@ -179,31 +173,25 @@ class AutofixCoordinator:
         if not cmd:
             return False
 
-        # Handle CompletedProcess objects or Mock objects with returncode attribute
         if hasattr(result, "returncode"):
             return self._check_process_result_success(result)
 
-        # Check for string patterns in result
         if isinstance(result, str):
             return self._check_string_result_success(result)
 
         return False
 
     def _check_process_result_success(self, result: object) -> bool:
-        """Check if a process result indicates success."""
         if getattr(result, "returncode", 1) == 0:
             return True
 
-        # Check output for success patterns if return code is non-zero
         output = self._extract_process_output(result)
         return self._has_success_patterns(output)
 
     def _extract_process_output(self, result: object) -> str:
-        """Extract and normalize stdout and stderr from process result."""
         stdout = getattr(result, "stdout", "") or ""
         stderr = getattr(result, "stderr", "") or ""
 
-        # Convert to strings if they're not already
         if not isinstance(stdout, str):
             stdout = str(stdout)
         if not isinstance(stderr, str):
@@ -212,11 +200,9 @@ class AutofixCoordinator:
         return stdout + stderr
 
     def _check_string_result_success(self, result: str) -> bool:
-        """Check if a string result indicates success."""
         return self._has_success_patterns(result)
 
     def _has_success_patterns(self, output: str) -> bool:
-        """Check if output contains success patterns."""
         if not output:
             return False
 
@@ -273,7 +259,7 @@ class AutofixCoordinator:
             raw_output = getattr(result, "raw_output", None)
             if raw_output:
                 output_lower = raw_output.lower()
-                # Skip autofix for import errors as they typically require manual intervention
+
                 if (
                     "importerror" in output_lower
                     or "modulenotfounderror" in output_lower

crackerjack/core/enhanced_container.py

@@ -44,7 +44,7 @@ class ServiceDescriptor:
     created_count: int = 0
     dependencies: list[type] = field(default_factory=list)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.implementation is self.factory is self.instance is None:
             msg = "Must provide either implementation, factory, or instance"
             raise ValueError(msg)
@@ -115,7 +115,6 @@ class DependencyResolver:
                     dependency = self.container.get(param.annotation)
                     kwargs[param_name] = dependency
                 except Exception as e:
-                    # Only log as warning for required parameters, debug for optional ones with defaults
                     if param.default == inspect.Parameter.empty:
                         self.logger.warning(
                             "Could not inject dependency",
@@ -147,7 +146,7 @@ class DependencyResolver:
 
     def _build_constructor_kwargs(self, implementation: type) -> dict[str, Any]:
         init_sig = inspect.signature(implementation.__init__)
-        kwargs = {}
+        kwargs: dict[str, Any] = {}
 
         for param_name, param in init_sig.parameters.items():
             if param_name == "self":
@@ -301,7 +300,7 @@ class EnhancedDependencyContainer:
         self._current_scope = scope
 
     def get_service_info(self) -> dict[str, Any]:
-        info = {}
+        info: dict[str, Any] = {}
 
         with self._lock:
             for key, descriptor in self._services.items():
@@ -392,7 +391,7 @@ class EnhancedDependencyContainer:
     def _get_service_key(self, interface: type) -> str:
         return f"{interface.__module__}.{interface.__name__}"
 
-    def __enter__(self):
+    def __enter__(self) -> "EnhancedDependencyContainer":
         return self
 
     def __exit__(
@@ -476,11 +475,9 @@ 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
 
@@ -491,7 +488,6 @@ class ServiceCollectionBuilder:
             factory=create_coverage_ratchet,
         )
 
-        # Register ConfigurationServiceProtocol
         def create_configuration_service() -> ConfigurationServiceProtocol:
             from crackerjack.services.config import ConfigurationService
 
@@ -502,7 +498,6 @@ class ServiceCollectionBuilder:
             factory=create_configuration_service,
         )
 
-        # Register SecurityServiceProtocol
         def create_security_service() -> SecurityServiceProtocol:
             from crackerjack.services.security import SecurityService
 
@@ -513,7 +508,6 @@ class ServiceCollectionBuilder:
             factory=create_security_service,
         )
 
-        # Register InitializationServiceProtocol
         def create_initialization_service() -> InitializationServiceProtocol:
             from crackerjack.services.filesystem import FileSystemService
             from crackerjack.services.git import GitService
@@ -536,19 +530,16 @@ class ServiceCollectionBuilder:
 
         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
 
         def create_config_merge_service() -> ConfigMergeService: