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

crackerjack/managers/async_hook_manager.py

@@ -25,12 +25,21 @@ class AsyncHookManager:
             quiet=True,
         )
         self.config_loader = HookConfigLoader()
+        self._config_path: Path | None = None
+
+    def set_config_path(self, config_path: Path) -> None:
+        """Set the path to the pre-commit configuration file."""
+        self._config_path = config_path
 
     async def run_fast_hooks_async(self) -> list[HookResult]:
         strategy = self.config_loader.load_strategy("fast")
 
         strategy.parallel = False
 
+        if self._config_path:
+            for hook in strategy.hooks:
+                hook.config_path = self._config_path
+
         execution_result = await self.async_executor.execute_strategy(strategy)
         return execution_result.results
 
@@ -40,6 +49,10 @@ class AsyncHookManager:
         strategy.parallel = True
         strategy.max_workers = 3
 
+        if self._config_path:
+            for hook in strategy.hooks:
+                hook.config_path = self._config_path
+
         execution_result = await self.async_executor.execute_strategy(strategy)
         return execution_result.results
 
@@ -52,6 +65,8 @@ class AsyncHookManager:
     async def install_hooks_async(self) -> bool:
         try:
             process = await asyncio.create_subprocess_exec(
+                "uv",
+                "run",
                 "pre-commit",
                 "install",
                 cwd=self.pkg_path,
@@ -62,19 +77,19 @@ class AsyncHookManager:
             _, stderr = await asyncio.wait_for(process.communicate(), timeout=30)
 
             if process.returncode == 0:
-                self.console.print("[green]✅[/green] Pre-commit hooks installed")
+                self.console.print("[green]✅[/ green] Pre-commit hooks installed")
                 return True
             error_msg = stderr.decode() if stderr else "Unknown error"
             self.console.print(
-                f"[red]❌[/red] Failed to install hooks: {error_msg}",
+                f"[red]❌[/ red] Failed to install hooks: {error_msg}",
             )
             return False
 
         except TimeoutError:
-            self.console.print("[red]❌[/red] Hook installation timed out")
+            self.console.print("[red]❌[/ red] Hook installation timed out")
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error installing hooks: {e}")
+            self.console.print(f"[red]❌[/ red] Error installing hooks: {e}")
             return False
 
     def install_hooks(self) -> bool:
@@ -83,6 +98,8 @@ class AsyncHookManager:
     async def update_hooks_async(self) -> bool:
         try:
             process = await asyncio.create_subprocess_exec(
+                "uv",
+                "run",
                 "pre-commit",
                 "autoupdate",
                 cwd=self.pkg_path,
@@ -93,17 +110,17 @@ class AsyncHookManager:
             _, stderr = await asyncio.wait_for(process.communicate(), timeout=60)
 
             if process.returncode == 0:
-                self.console.print("[green]✅[/green] Pre-commit hooks updated")
+                self.console.print("[green]✅[/ green] Pre-commit hooks updated")
                 return True
             error_msg = stderr.decode() if stderr else "Unknown error"
-            self.console.print(f"[red]❌[/red] Failed to update hooks: {error_msg}")
+            self.console.print(f"[red]❌[/ red] Failed to update hooks: {error_msg}")
             return False
 
         except TimeoutError:
-            self.console.print("[red]❌[/red] Hook update timed out")
+            self.console.print("[red]❌[/ red] Hook update timed out")
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error updating hooks: {e}")
+            self.console.print(f"[red]❌[/ red] Error updating hooks: {e}")
             return False
 
     def update_hooks(self) -> bool:

crackerjack/managers/hook_manager.py

@@ -52,7 +52,7 @@ class HookManagerImpl:
     def validate_hooks_config(self) -> bool:
         try:
             result = subprocess.run(
-                ["pre-commit", "validate-config"],
+                ["uv", "run", "pre-commit", "validate-config"],
                 cwd=self.pkg_path,
                 capture_output=True,
                 text=True,
@@ -72,7 +72,7 @@ class HookManagerImpl:
     def install_hooks(self) -> bool:
         try:
             result = subprocess.run(
-                ["pre-commit", "install"],
+                ["uv", "run", "pre-commit", "install"],
                 check=False,
                 cwd=self.pkg_path,
                 capture_output=True,
@@ -80,20 +80,20 @@ class HookManagerImpl:
                 timeout=30,
             )
             if result.returncode == 0:
-                self.console.print("[green]✅[/green] Pre-commit hooks installed")
+                self.console.print("[green]✅[/ green] Pre-commit hooks installed")
                 return True
             self.console.print(
-                f"[red]❌[/red] Failed to install hooks: {result.stderr}",
+                f"[red]❌[/ red] Failed to install hooks: {result.stderr}",
             )
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error installing hooks: {e}")
+            self.console.print(f"[red]❌[/ red] Error installing hooks: {e}")
             return False
 
     def update_hooks(self) -> bool:
         try:
             result = subprocess.run(
-                ["pre-commit", "autoupdate"],
+                ["uv", "run", "pre-commit", "autoupdate"],
                 check=False,
                 cwd=self.pkg_path,
                 capture_output=True,
@@ -101,14 +101,14 @@ class HookManagerImpl:
                 timeout=60,
             )
             if result.returncode == 0:
-                self.console.print("[green]✅[/green] Pre-commit hooks updated")
+                self.console.print("[green]✅[/ green] Pre-commit hooks updated")
                 return True
             self.console.print(
-                f"[red]❌[/red] Failed to update hooks: {result.stderr}",
+                f"[red]❌[/ red] Failed to update hooks: {result.stderr}",
             )
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error updating hooks: {e}")
+            self.console.print(f"[red]❌[/ red] Error updating hooks: {e}")
             return False
 
     def get_hook_summary(self, results: list[HookResult]) -> dict[str, t.Any]:

crackerjack/managers/publish_manager.py

@@ -52,32 +52,29 @@ class PublishManagerImpl:
             data = loads(content)
             return data.get("project", {}).get("version")
         except Exception as e:
-            self.console.print(f"[yellow]⚠️[/yellow] Error reading version: {e}")
+            self.console.print(f"[yellow]⚠️[/ yellow] Error reading version: {e}")
             return None
 
     def _update_version_in_file(self, new_version: str) -> bool:
         pyproject_path = self.pkg_path / "pyproject.toml"
         try:
             content = self.filesystem.read_file(pyproject_path)
-            import re
+            from crackerjack.services.regex_patterns import update_pyproject_version
 
-            # More specific pattern to only match project version, not tool versions
-            pattern = r'^(version\s*=\s*["\'])([^"\']+)(["\'])$'
-            replacement = f"\\g<1>{new_version}\\g<3>"
-            new_content = re.sub(pattern, replacement, content, flags=re.MULTILINE)
+            new_content = update_pyproject_version(content, new_version)
             if content != new_content:
                 if not self.dry_run:
                     self.filesystem.write_file(pyproject_path, new_content)
                 self.console.print(
-                    f"[green]✅[/green] Updated version to {new_version}",
+                    f"[green]✅[/ green] Updated version to {new_version}",
                 )
                 return True
             self.console.print(
-                "[yellow]⚠️[/yellow] Version pattern not found in pyproject.toml",
+                "[yellow]⚠️[/ yellow] Version pattern not found in pyproject.toml",
             )
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error updating version: {e}")
+            self.console.print(f"[red]❌[/ red] Error updating version: {e}")
             return False
 
     def _calculate_next_version(self, current: str, bump_type: str) -> str:
@@ -96,18 +93,17 @@ class PublishManagerImpl:
             msg = f"Invalid bump type: {bump_type}"
             raise ValueError(msg)
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error calculating version: {e}")
+            self.console.print(f"[red]❌[/ red] Error calculating version: {e}")
             raise
 
     def bump_version(self, version_type: str) -> str:
         current_version = self._get_current_version()
         if not current_version:
-            self.console.print("[red]❌[/red] Could not determine current version")
+            self.console.print("[red]❌[/ red] Could not determine current version")
             msg = "Cannot determine current version"
             raise ValueError(msg)
-        self.console.print(f"[cyan]📦[/cyan] Current version: {current_version}")
+        self.console.print(f"[cyan]📦[/ cyan] Current version: {current_version}")
 
-        # Handle interactive version selection
         if version_type == "interactive":
             version_type = self._prompt_for_version_type()
 
@@ -115,11 +111,11 @@ class PublishManagerImpl:
             new_version = self._calculate_next_version(current_version, version_type)
             if self.dry_run:
                 self.console.print(
-                    f"[yellow]🔍[/yellow] Would bump {version_type} version: {current_version} → {new_version}",
+                    f"[yellow]🔍[/ yellow] Would bump {version_type} version: {current_version} → {new_version}",
                 )
             elif self._update_version_in_file(new_version):
                 self.console.print(
-                    f"[green]🚀[/green] Bumped {version_type} version: {current_version} → {new_version}",
+                    f"[green]🚀[/ green] Bumped {version_type} version: {current_version} → {new_version}",
                 )
             else:
                 msg = "Failed to update version in file"
@@ -127,22 +123,21 @@ class PublishManagerImpl:
 
             return new_version
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Version bump failed: {e}")
+            self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             raise
 
     def _prompt_for_version_type(self) -> str:
-        """Prompt user to select version type interactively."""
         try:
             from rich.prompt import Prompt
 
             return Prompt.ask(
-                "[cyan]📦[/cyan] Select version bump type",
+                "[cyan]📦[/ cyan] Select version bump type",
                 choices=["patch", "minor", "major"],
                 default="patch",
             )
         except ImportError:
             self.console.print(
-                "[yellow]⚠️[/yellow] Rich prompt not available, defaulting to patch"
+                "[yellow]⚠️[/ yellow] Rich prompt not available, defaulting to patch"
             )
             return "patch"
 
@@ -172,24 +167,29 @@ class PublishManagerImpl:
 
         if self.security.validate_token_format(token, "pypi"):
             masked_token = self.security.mask_tokens(token)
-            self.console.print(f"[dim]Token format: {masked_token}[/dim]", style="dim")
+            self.console.print(f"[dim]Token format: {masked_token}[/ dim]", style="dim")
             return "Environment variable (UV_PUBLISH_TOKEN)"
         self.console.print(
-            "[yellow]⚠️[/yellow] UV_PUBLISH_TOKEN format appears invalid",
+            "[yellow]⚠️[/ yellow] UV_PUBLISH_TOKEN format appears invalid",
         )
         return None
 
     def _check_keyring_auth(self) -> str | None:
         try:
             result = self._run_command(
-                ["keyring", "get", "https://upload.pypi.org/legacy/", "__token__"],
+                [
+                    "keyring",
+                    "get",
+                    "https://upload.pypi.org/legacy/",
+                    "__token__",
+                ],
             )
             if result.returncode == 0 and result.stdout.strip():
                 keyring_token = result.stdout.strip()
                 if self.security.validate_token_format(keyring_token, "pypi"):
                     return "Keyring storage"
                 self.console.print(
-                    "[yellow]⚠️[/yellow] Keyring token format appears invalid",
+                    "[yellow]⚠️[/ yellow] Keyring token format appears invalid",
                 )
         except (subprocess.SubprocessError, OSError, FileNotFoundError):
             pass
@@ -197,16 +197,16 @@ class PublishManagerImpl:
 
     def _report_auth_status(self, auth_methods: list[str]) -> bool:
         if auth_methods:
-            self.console.print("[green]✅[/green] PyPI authentication available: ")
+            self.console.print("[green]✅[/ green] PyPI authentication available: ")
             for method in auth_methods:
-                self.console.print(f" - {method}")
+                self.console.print(f"-{method}")
             return True
         self._display_auth_setup_instructions()
         return False
 
     def _display_auth_setup_instructions(self) -> None:
-        self.console.print("[red]❌[/red] No valid PyPI authentication found")
-        self.console.print("\n[yellow]💡[/yellow] Setup options: ")
+        self.console.print("[red]❌[/ red] No valid PyPI authentication found")
+        self.console.print("\n[yellow]💡[/ yellow] Setup options: ")
         self.console.print(
             " 1. Set environment variable: export UV_PUBLISH_TOKEN=<your-pypi-token>",
         )
@@ -219,22 +219,21 @@ class PublishManagerImpl:
 
     def build_package(self) -> bool:
         try:
-            self.console.print("[yellow]🔨[/yellow] Building package...")
+            self.console.print("[yellow]🔨[/ yellow] Building package...")
 
             if self.dry_run:
                 return self._handle_dry_run_build()
 
             return self._execute_build()
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Build error: {e}")
+            self.console.print(f"[red]❌[/ red] Build error: {e}")
             return False
 
     def _handle_dry_run_build(self) -> bool:
-        self.console.print("[yellow]🔍[/yellow] Would build package")
+        self.console.print("[yellow]🔍[/ yellow] Would build package")
         return True
 
     def _clean_dist_directory(self) -> None:
-        """Clean dist directory to ensure only current version artifacts are uploaded."""
         dist_dir = self.pkg_path / "dist"
         if not dist_dir.exists():
             return
@@ -242,27 +241,26 @@ class PublishManagerImpl:
         try:
             import shutil
 
-            # Remove entire dist directory and recreate it
             shutil.rmtree(dist_dir)
             dist_dir.mkdir(exist_ok=True)
-            self.console.print("[cyan]🧹[/cyan] Cleaned dist directory for fresh build")
+            self.console.print(
+                "[cyan]🧹[/ cyan] Cleaned dist directory for fresh build"
+            )
         except Exception as e:
             self.console.print(
-                f"[yellow]⚠️[/yellow] Warning: Could not clean dist directory: {e}"
+                f"[yellow]⚠️[/ yellow] Warning: Could not clean dist directory: {e}"
             )
-            # Continue with build anyway - uv publish will fail with clear error
 
     def _execute_build(self) -> bool:
-        # Clean dist directory before building to avoid uploading multiple versions
         self._clean_dist_directory()
 
         result = self._run_command(["uv", "build"])
 
         if result.returncode != 0:
-            self.console.print(f"[red]❌[/red] Build failed: {result.stderr}")
+            self.console.print(f"[red]❌[/ red] Build failed: {result.stderr}")
             return False
 
-        self.console.print("[green]✅[/green] Package built successfully")
+        self.console.print("[green]✅[/ green] Package built successfully")
         self._display_build_artifacts()
         return True
 
@@ -272,11 +270,11 @@ class PublishManagerImpl:
             return
 
         artifacts = list(dist_dir.glob("*"))
-        self.console.print(f"[cyan]📦[/cyan] Build artifacts ({len(artifacts)}): ")
+        self.console.print(f"[cyan]📦[/ cyan] Build artifacts ({len(artifacts)}): ")
 
         for artifact in artifacts[-5:]:
             size_str = self._format_file_size(artifact.stat().st_size)
-            self.console.print(f" - {artifact.name} ({size_str})")
+            self.console.print(f"-{artifact.name} ({size_str})")
 
     def _format_file_size(self, size: int) -> str:
         if size < 1024 * 1024:
@@ -288,10 +286,10 @@ class PublishManagerImpl:
             return False
 
         try:
-            self.console.print("[yellow]🚀[/yellow] Publishing to PyPI...")
+            self.console.print("[yellow]🚀[/ yellow] Publishing to PyPI...")
             return self._perform_publish_workflow()
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Publish error: {e}")
+            self.console.print(f"[red]❌[/ red] Publish error: {e}")
             return False
 
     def _validate_prerequisites(self) -> bool:
@@ -307,7 +305,7 @@ class PublishManagerImpl:
         return self._execute_publish()
 
     def _handle_dry_run_publish(self) -> bool:
-        self.console.print("[yellow]🔍[/yellow] Would publish package to PyPI")
+        self.console.print("[yellow]🔍[/ yellow] Would publish package to PyPI")
         return True
 
     def _execute_publish(self) -> bool:
@@ -321,10 +319,10 @@ class PublishManagerImpl:
         return True
 
     def _handle_publish_failure(self, error_msg: str) -> None:
-        self.console.print(f"[red]❌[/red] Publish failed: {error_msg}")
+        self.console.print(f"[red]❌[/ red] Publish failed: {error_msg}")
 
     def _handle_publish_success(self) -> None:
-        self.console.print("[green]🎉[/green] Package published successfully!")
+        self.console.print("[green]🎉[/ green] Package published successfully !")
         self._display_package_url()
 
     def _display_package_url(self) -> None:
@@ -333,7 +331,7 @@ class PublishManagerImpl:
 
         if package_name and current_version:
             url = f"https://pypi.org/project/{package_name}/{current_version}/"
-            self.console.print(f"[cyan]🔗[/cyan] Package URL: {url}")
+            self.console.print(f"[cyan]🔗[/ cyan] Package URL: {url}")
 
     def _get_package_name(self) -> str | None:
         pyproject_path = self.pkg_path / "pyproject.toml"
@@ -350,11 +348,11 @@ class PublishManagerImpl:
     def cleanup_old_releases(self, keep_releases: int = 10) -> bool:
         try:
             self.console.print(
-                f"[yellow]🧹[/yellow] Cleaning up old releases (keeping {keep_releases})...",
+                f"[yellow]🧹[/ yellow] Cleaning up old releases (keeping {keep_releases})...",
             )
             if self.dry_run:
                 self.console.print(
-                    "[yellow]🔍[/yellow] Would clean up old PyPI releases",
+                    "[yellow]🔍[/ yellow] Would clean up old PyPI releases",
                 )
                 return True
             pyproject_path = self.pkg_path / "pyproject.toml"
@@ -365,48 +363,48 @@ class PublishManagerImpl:
             package_name = data.get("project", {}).get("name", "")
             if not package_name:
                 self.console.print(
-                    "[yellow]⚠️[/yellow] Could not determine package name",
+                    "[yellow]⚠️[/ yellow] Could not determine package name",
                 )
                 return False
             self.console.print(
-                f"[cyan]📦[/cyan] Would analyze releases for {package_name}",
+                f"[cyan]📦[/ cyan] Would analyze releases for {package_name}",
             )
             self.console.print(
-                f"[cyan]🔧[/cyan] Would keep {keep_releases} most recent releases",
+                f"[cyan]🔧[/ cyan] Would keep {keep_releases} most recent releases",
             )
 
             return True
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Cleanup error: {e}")
+            self.console.print(f"[red]❌[/ red] Cleanup error: {e}")
             return False
 
     def create_git_tag(self, version: str) -> bool:
         try:
             if self.dry_run:
                 self.console.print(
-                    f"[yellow]🔍[/yellow] Would create git tag: v{version}",
+                    f"[yellow]🔍[/ yellow] Would create git tag: v{version}",
                 )
                 return True
             result = self._run_command(["git", "tag", f"v{version}"])
             if result.returncode == 0:
-                self.console.print(f"[green]🏷️[/green] Created git tag: v{version}")
+                self.console.print(f"[green]🏷️[/ green] Created git tag: v{version}")
                 push_result = self._run_command(
                     ["git", "push", "origin", f"v{version}"],
                 )
                 if push_result.returncode == 0:
-                    self.console.print("[green]📤[/green] Pushed tag to remote")
+                    self.console.print("[green]📤[/ green] Pushed tag to remote")
                 else:
                     self.console.print(
-                        f"[yellow]⚠️[/yellow] Tag created but push failed: {push_result.stderr}",
+                        f"[yellow]⚠️[/ yellow] Tag created but push failed: {push_result.stderr}",
                     )
 
                 return True
             self.console.print(
-                f"[red]❌[/red] Failed to create tag: {result.stderr}",
+                f"[red]❌[/ red] Failed to create tag: {result.stderr}",
             )
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Tag creation error: {e}")
+            self.console.print(f"[red]❌[/ red] Tag creation error: {e}")
             return False
 
     def get_package_info(self) -> dict[str, t.Any]:
@@ -429,5 +427,5 @@ class PublishManagerImpl:
                 "python_requires": project.get("requires-python", ""),
             }
         except Exception as e:
-            self.console.print(f"[yellow]⚠️[/yellow] Error reading package info: {e}")
+            self.console.print(f"[yellow]⚠️[/ yellow] Error reading package info: {e}")
             return {}

crackerjack/managers/test_command_builder.py

@@ -1,22 +1,13 @@
-"""Test command building and configuration.
-
-This module handles pytest command construction with various options and configurations.
-Split from test_manager.py for better separation of concerns.
-"""
-
 from pathlib import Path
 
 from crackerjack.models.protocols import OptionsProtocol
 
 
 class TestCommandBuilder:
-    """Builds pytest commands with appropriate options and configurations."""
-
     def __init__(self, pkg_path: Path) -> None:
         self.pkg_path = pkg_path
 
     def build_command(self, options: OptionsProtocol) -> list[str]:
-        """Build complete pytest command with all options."""
         cmd = ["python", "-m", "pytest"]
 
         self._add_coverage_options(cmd, options)
@@ -29,16 +20,13 @@ class TestCommandBuilder:
         return cmd
 
     def get_optimal_workers(self, options: OptionsProtocol) -> int:
-        """Calculate optimal number of pytest workers based on system and configuration."""
         if hasattr(options, "test_workers") and options.test_workers:
             return options.test_workers
 
-        # Auto-detect based on CPU count
         import multiprocessing
 
         cpu_count = multiprocessing.cpu_count()
 
-        # Conservative worker count to avoid overwhelming the system
         if cpu_count <= 2:
             return 1
         elif cpu_count <= 4:
@@ -48,35 +36,29 @@ class TestCommandBuilder:
         return 4
 
     def get_test_timeout(self, options: OptionsProtocol) -> int:
-        """Get test timeout based on options or default."""
         if hasattr(options, "test_timeout") and options.test_timeout:
             return options.test_timeout
 
-        # Default timeout based on test configuration
         if hasattr(options, "benchmark") and options.benchmark:
-            return 900  # 15 minutes for benchmarks
-        return 300  # 5 minutes for regular tests
+            return 900
+        return 300
 
     def _add_coverage_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        """Add coverage-related options to command."""
-        # Always include coverage for comprehensive testing
         cmd.extend(
             [
                 "--cov=crackerjack",
                 "--cov-report=term-missing",
                 "--cov-report=html",
-                "--cov-fail-under=0",  # Don't fail on low coverage, let ratchet handle it
+                "--cov-fail-under=0",
             ]
         )
 
     def _add_worker_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        """Add parallel execution options to command."""
         workers = self.get_optimal_workers(options)
         if workers > 1:
             cmd.extend(["-n", str(workers)])
 
     def _add_benchmark_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        """Add benchmark-specific options to command."""
         if hasattr(options, "benchmark") and options.benchmark:
             cmd.extend(
                 [
@@ -87,27 +69,21 @@ class TestCommandBuilder:
             )
 
     def _add_timeout_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        """Add timeout options to command."""
         timeout = self.get_test_timeout(options)
         cmd.extend(["--timeout", str(timeout)])
 
     def _add_verbosity_options(self, cmd: list[str], options: OptionsProtocol) -> None:
-        """Add verbosity and output formatting options."""
-        # Always use verbose output for better progress tracking
         cmd.append("-v")
 
-        # Add useful output options
         cmd.extend(
             [
-                "--tb=short",  # Shorter traceback format
-                "--strict-markers",  # Ensure all markers are defined
-                "--strict-config",  # Ensure configuration is valid
+                "--tb=short",
+                "--strict-markers",
+                "--strict-config",
             ]
         )
 
     def _add_test_path(self, cmd: list[str]) -> None:
-        """Add test path to command."""
-        # Add tests directory if it exists, otherwise current directory
         test_paths = ["tests", "test"]
 
         for test_path in test_paths:
@@ -116,14 +92,11 @@ class TestCommandBuilder:
                 cmd.append(str(full_path))
                 return
 
-        # Fallback to current directory
         cmd.append(str(self.pkg_path))
 
     def build_specific_test_command(self, test_pattern: str) -> list[str]:
-        """Build command for running specific tests matching a pattern."""
         cmd = ["python", "-m", "pytest", "-v"]
 
-        # Add basic coverage
         cmd.extend(
             [
                 "--cov=crackerjack",
@@ -131,16 +104,13 @@ class TestCommandBuilder:
             ]
         )
 
-        # Add the test pattern
         cmd.extend(["-k", test_pattern])
 
-        # Add test path
         self._add_test_path(cmd)
 
         return cmd
 
     def build_validation_command(self) -> list[str]:
-        """Build command for test environment validation."""
         return [
             "python",
             "-m",