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

crackerjack/crackerjack.py

@@ -1,4140 +0,0 @@
-import asyncio
-import json
-import operator
-import re
-import subprocess
-import time
-import typing as t
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from contextlib import suppress
-from dataclasses import dataclass
-from functools import lru_cache
-from pathlib import Path
-from subprocess import CompletedProcess
-from subprocess import run as execute
-from tomllib import loads
-
-import aiofiles
-from pydantic import BaseModel
-from rich.console import Console
-from tomli_w import dumps
-
-from .errors import ErrorCode, ExecutionError
-
-
-@dataclass
-class HookResult:
-    id: str
-    name: str
-    status: str
-    duration: float
-    files_processed: int = 0
-    issues_found: list[str] | None = None
-    stage: str = "pre-commit"
-
-    def __post_init__(self) -> None:
-        if self.issues_found is None:
-            self.issues_found = []
-
-
-@dataclass
-class TaskStatus:
-    id: str
-    name: str
-    status: str
-    start_time: float | None = None
-    end_time: float | None = None
-    duration: float | None = None
-    details: str | None = None
-    error_message: str | None = None
-    files_changed: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.files_changed is None:
-            self.files_changed = []
-        if self.start_time is not None and self.end_time is not None:
-            self.duration = self.end_time - self.start_time
-
-
-class SessionTracker(BaseModel, arbitrary_types_allowed=True):
-    console: Console
-    session_id: str
-    start_time: float
-    progress_file: Path
-    tasks: dict[str, TaskStatus] = {}
-    current_task: str | None = None
-    metadata: dict[str, t.Any] = {}
-
-    def __init__(self, **data: t.Any) -> None:
-        super().__init__(**data)
-        if not self.tasks:
-            self.tasks = {}
-        if not self.metadata:
-            self.metadata = {}
-
-    def start_task(
-        self, task_id: str, task_name: str, details: str | None = None
-    ) -> None:
-        task = TaskStatus(
-            id=task_id,
-            name=task_name,
-            status="in_progress",
-            start_time=time.time(),
-            details=details,
-        )
-        self.tasks[task_id] = task
-        self.current_task = task_id
-        self._update_progress_file()
-        self.console.print(f"[yellow]⏳[/yellow] Started: {task_name}")
-
-    def complete_task(
-        self,
-        task_id: str,
-        details: str | None = None,
-        files_changed: list[str] | None = None,
-    ) -> None:
-        if task_id in self.tasks:
-            task = self.tasks[task_id]
-            task.status = "completed"
-            task.end_time = time.time()
-            task.duration = task.end_time - (task.start_time or task.end_time)
-            if details:
-                task.details = details
-            if files_changed:
-                task.files_changed = files_changed
-            self._update_progress_file()
-            self.console.print(f"[green]✅[/green] Completed: {task.name}")
-            if self.current_task == task_id:
-                self.current_task = None
-
-    def fail_task(
-        self,
-        task_id: str,
-        error_message: str,
-        details: str | None = None,
-    ) -> None:
-        if task_id in self.tasks:
-            task = self.tasks[task_id]
-            task.status = "failed"
-            task.end_time = time.time()
-            task.duration = task.end_time - (task.start_time or task.end_time)
-            task.error_message = error_message
-            if details:
-                task.details = details
-            self._update_progress_file()
-            self.console.print(f"[red]❌[/red] Failed: {task.name} - {error_message}")
-            if self.current_task == task_id:
-                self.current_task = None
-
-    def skip_task(self, task_id: str, reason: str) -> None:
-        if task_id in self.tasks:
-            task = self.tasks[task_id]
-            task.status = "skipped"
-            task.end_time = time.time()
-            task.details = f"Skipped: {reason}"
-            self._update_progress_file()
-            self.console.print(f"[blue]⏩[/blue] Skipped: {task.name} - {reason}")
-            if self.current_task == task_id:
-                self.current_task = None
-
-    def _update_progress_file(self) -> None:
-        try:
-            content = self._generate_markdown_content()
-            self.progress_file.write_text(content, encoding="utf-8")
-        except OSError as e:
-            self.console.print(
-                f"[yellow]Warning: Failed to update progress file: {e}[/yellow]"
-            )
-
-    def _generate_header_section(self) -> str:
-        from datetime import datetime
-
-        completed_tasks = sum(
-            1 for task in self.tasks.values() if task.status == "completed"
-        )
-        total_tasks = len(self.tasks)
-        overall_status = "In Progress"
-        if completed_tasks == total_tasks and total_tasks > 0:
-            overall_status = "Completed"
-        elif any(task.status == "failed" for task in self.tasks.values()):
-            overall_status = "Failed"
-        start_datetime = datetime.fromtimestamp(self.start_time)
-
-        return f"""# Crackerjack Session Progress: {self.session_id}
-**Session ID**: {self.session_id}
-**Started**: {start_datetime.strftime("%Y-%m-%d %H:%M:%S")}
-**Status**: {overall_status}
-**Progress**: {completed_tasks}/{total_tasks} tasks completed
-
-- **Working Directory**: {self.metadata.get("working_dir", Path.cwd())}
-- **Python Version**: {self.metadata.get("python_version", "Unknown")}
-- **Crackerjack Version**: {self.metadata.get("crackerjack_version", "Unknown")}
-- **CLI Options**: {self.metadata.get("cli_options", "Unknown")}
-
-"""
-
-    def _generate_task_overview_section(self) -> str:
-        content = """## Task Progress Overview
-| Task | Status | Duration | Details |
-|------|--------|----------|---------|
-"""
-
-        for task in self.tasks.values():
-            status_emoji = {
-                "pending": "⏸️",
-                "in_progress": "⏳",
-                "completed": "✅",
-                "failed": "❌",
-                "skipped": "⏩",
-            }.get(task.status, "❓")
-
-            duration_str = f"{task.duration:.2f}s" if task.duration else "N/A"
-            details_str = (
-                task.details[:50] + "..."
-                if task.details and len(task.details) > 50
-                else (task.details or "")
-            )
-
-            content += f"| {task.name} | {status_emoji} {task.status} | {duration_str} | {details_str} |\n"
-
-        return content + "\n"
-
-    def _generate_task_details_section(self) -> str:
-        content = "## Detailed Task Log\n\n"
-        for task in self.tasks.values():
-            content += self._format_task_detail(task)
-        return content
-
-    def _format_task_detail(self, task: TaskStatus) -> str:
-        from datetime import datetime
-
-        if task.status == "completed":
-            return self._format_completed_task(task, datetime)
-        elif task.status == "in_progress":
-            return self._format_in_progress_task(task, datetime)
-        elif task.status == "failed":
-            return self._format_failed_task(task, datetime)
-        elif task.status == "skipped":
-            return self._format_skipped_task(task)
-        return ""
-
-    def _format_completed_task(self, task: TaskStatus, datetime: t.Any) -> str:
-        start_time = (
-            datetime.fromtimestamp(task.start_time) if task.start_time else "Unknown"
-        )
-        end_time = datetime.fromtimestamp(task.end_time) if task.end_time else "Unknown"
-        files_list = ", ".join(task.files_changed) if task.files_changed else "None"
-        return f"""### ✅ {task.name} - COMPLETED
-- **Started**: {start_time}
-- **Completed**: {end_time}
-- **Duration**: {task.duration:.2f}s
-- **Files Changed**: {files_list}
-- **Details**: {task.details or "N/A"}
-
-"""
-
-    def _format_in_progress_task(self, task: TaskStatus, datetime: t.Any) -> str:
-        start_time = (
-            datetime.fromtimestamp(task.start_time) if task.start_time else "Unknown"
-        )
-        return f"""### ⏳ {task.name} - IN PROGRESS
-- **Started**: {start_time}
-- **Current Status**: {task.details or "Processing..."}
-
-"""
-
-    def _format_failed_task(self, task: TaskStatus, datetime: t.Any) -> str:
-        start_time = (
-            datetime.fromtimestamp(task.start_time) if task.start_time else "Unknown"
-        )
-        fail_time = (
-            datetime.fromtimestamp(task.end_time) if task.end_time else "Unknown"
-        )
-        return f"""### ❌ {task.name} - FAILED
-- **Started**: {start_time}
-- **Failed**: {fail_time}
-- **Error**: {task.error_message or "Unknown error"}
-- **Recovery Suggestions**: Check error details and retry the failed operation
-
-"""
-
-    def _format_skipped_task(self, task: TaskStatus) -> str:
-        return f"""### ⏩ {task.name} - SKIPPED
-- **Reason**: {task.details or "No reason provided"}
-
-"""
-
-    def _generate_footer_section(self) -> str:
-        content = f"""## Session Recovery Information
-If this session was interrupted, you can resume from where you left off:
-
-```bash
-python -m crackerjack --resume-from {self.progress_file.name}
-```
-
-"""
-
-        all_files: set[str] = set()
-        for task in self.tasks.values():
-            if task.files_changed:
-                all_files.update(task.files_changed)
-
-        if all_files:
-            for file_path in sorted(all_files):
-                content += f"- {file_path}\n"
-        else:
-            content += "- No files modified yet\n"
-
-        content += "\n## Next Steps\n\n"
-
-        pending_tasks = [
-            task for task in self.tasks.values() if task.status == "pending"
-        ]
-        in_progress_tasks = [
-            task for task in self.tasks.values() if task.status == "in_progress"
-        ]
-        failed_tasks = [task for task in self.tasks.values() if task.status == "failed"]
-
-        if failed_tasks:
-            content += "⚠️ Address failed tasks:\n"
-            for task in failed_tasks:
-                content += f"- Fix {task.name}: {task.error_message}\n"
-        elif in_progress_tasks:
-            content += "🔄 Currently working on:\n"
-            for task in in_progress_tasks:
-                content += f"- {task.name}\n"
-        elif pending_tasks:
-            content += "📋 Next tasks to complete:\n"
-            for task in pending_tasks:
-                content += f"- {task.name}\n"
-        else:
-            content += "🎉 All tasks completed successfully!\n"
-
-        return content
-
-    def _generate_markdown_content(self) -> str:
-        return (
-            self._generate_header_section()
-            + self._generate_task_overview_section()
-            + self._generate_task_details_section()
-            + self._generate_footer_section()
-        )
-
-    @classmethod
-    def create_session(
-        cls,
-        console: Console,
-        session_id: str | None = None,
-        progress_file: Path | None = None,
-        metadata: dict[str, t.Any] | None = None,
-    ) -> "SessionTracker":
-        import uuid
-
-        if session_id is None:
-            session_id = str(uuid.uuid4())[:8]
-
-        if progress_file is None:
-            timestamp = time.strftime("%Y%m%d-%H%M%S")
-            progress_file = Path(f"SESSION-PROGRESS-{timestamp}.md")
-
-        tracker = cls(
-            console=console,
-            session_id=session_id,
-            start_time=time.time(),
-            progress_file=progress_file,
-            metadata=metadata or {},
-        )
-
-        tracker._update_progress_file()
-        console.print(f"[green]📋[/green] Session tracking started: {progress_file}")
-        return tracker
-
-    @classmethod
-    def find_recent_progress_files(cls, directory: Path = Path.cwd()) -> list[Path]:
-        progress_files: list[Path] = []
-        for file_path in directory.glob("SESSION-PROGRESS-*.md"):
-            try:
-                if file_path.is_file():
-                    progress_files.append(file_path)
-            except (OSError, PermissionError):
-                continue
-
-        return sorted(progress_files, key=lambda p: p.stat().st_mtime, reverse=True)
-
-    @classmethod
-    def is_session_incomplete(cls, progress_file: Path) -> bool:
-        if not progress_file.exists():
-            return False
-        try:
-            content = progress_file.read_text(encoding="utf-8")
-            has_in_progress = "⏳" in content or "in_progress" in content
-            has_failed = "❌" in content or "failed" in content
-            has_pending = "⏸️" in content or "pending" in content
-            stat = progress_file.stat()
-            age_hours = (time.time() - stat.st_mtime) / 3600
-            is_recent = age_hours < 24
-
-            return (has_in_progress or has_failed or has_pending) and is_recent
-        except (OSError, UnicodeDecodeError):
-            return False
-
-    @classmethod
-    def find_incomplete_session(cls, directory: Path = Path.cwd()) -> Path | None:
-        recent_files = cls.find_recent_progress_files(directory)
-        for progress_file in recent_files:
-            if cls.is_session_incomplete(progress_file):
-                return progress_file
-
-        return None
-
-    @classmethod
-    def auto_detect_session(
-        cls, console: Console, directory: Path = Path.cwd()
-    ) -> "SessionTracker | None":
-        incomplete_session = cls.find_incomplete_session(directory)
-        if incomplete_session:
-            return cls._handle_incomplete_session(console, incomplete_session)
-        return None
-
-    @classmethod
-    def _handle_incomplete_session(
-        cls, console: Console, incomplete_session: Path
-    ) -> "SessionTracker | None":
-        console.print(
-            f"[yellow]📋[/yellow] Found incomplete session: {incomplete_session.name}"
-        )
-        try:
-            content = incomplete_session.read_text(encoding="utf-8")
-            session_info = cls._parse_session_info(content)
-            cls._display_session_info(console, session_info)
-            return cls._prompt_resume_session(console, incomplete_session)
-        except Exception as e:
-            console.print(f"[yellow]⚠️[/yellow] Could not parse session file: {e}")
-            return None
-
-    @classmethod
-    def _parse_session_info(cls, content: str) -> dict[str, str | list[str] | None]:
-        import re
-
-        session_match = re.search(r"Session ID\*\*:\s*(.+)", content)
-        session_id: str = session_match.group(1).strip() if session_match else "unknown"
-        progress_match = re.search(r"Progress\*\*:\s*(\d+)/(\d+)", content)
-        progress_info: str | None = None
-        if progress_match:
-            completed = progress_match.group(1)
-            total = progress_match.group(2)
-            progress_info = f"{completed}/{total} tasks completed"
-        failed_tasks: list[str] = []
-        for line in content.split("\n"):
-            if "❌" in line and "- FAILED" in line:
-                task_match = re.search(r"### ❌ (.+?) - FAILED", line)
-                if task_match:
-                    task_name: str = task_match.group(1)
-                    failed_tasks.append(task_name)
-
-        return {
-            "session_id": session_id,
-            "progress_info": progress_info,
-            "failed_tasks": failed_tasks,
-        }
-
-    @classmethod
-    def _display_session_info(
-        cls, console: Console, session_info: dict[str, str | list[str] | None]
-    ) -> None:
-        console.print(f"[cyan]   Session ID:[/cyan] {session_info['session_id']}")
-        if session_info["progress_info"]:
-            console.print(f"[cyan]   Progress:[/cyan] {session_info['progress_info']}")
-        if session_info["failed_tasks"]:
-            console.print(
-                f"[red]   Failed tasks:[/red] {', '.join(session_info['failed_tasks'])}"
-            )
-
-    @classmethod
-    def _prompt_resume_session(
-        cls, console: Console, incomplete_session: Path
-    ) -> "SessionTracker | None":
-        try:
-            import sys
-
-            console.print("[yellow]❓[/yellow] Resume this session? [y/N]: ", end="")
-            sys.stdout.flush()
-            response = input().strip().lower()
-            if response in ("y", "yes"):
-                return cls.resume_session(console, incomplete_session)
-            else:
-                console.print("[blue]ℹ️[/blue] Starting new session instead")
-                return None
-        except (KeyboardInterrupt, EOFError):
-            console.print("\n[blue]ℹ️[/blue] Starting new session instead")
-            return None
-
-    @classmethod
-    def resume_session(cls, console: Console, progress_file: Path) -> "SessionTracker":
-        if not progress_file.exists():
-            raise FileNotFoundError(f"Progress file not found: {progress_file}")
-        try:
-            content = progress_file.read_text(encoding="utf-8")
-            session_id = "resumed"
-            import re
-
-            session_match = re.search(r"Session ID\*\*:\s*(.+)", content)
-            if session_match:
-                session_id = session_match.group(1).strip()
-            tracker = cls(
-                console=console,
-                session_id=session_id,
-                start_time=time.time(),
-                progress_file=progress_file,
-                metadata={},
-            )
-            console.print(f"[green]🔄[/green] Resumed session from: {progress_file}")
-            return tracker
-        except Exception as e:
-            raise RuntimeError(f"Failed to resume session: {e}") from e
-
-
-config_files = (
-    ".gitignore",
-    ".pre-commit-config.yaml",
-    ".pre-commit-config-ai.yaml",
-    ".pre-commit-config-fast.yaml",
-    ".libcst.codemod.yaml",
-)
-
-documentation_files = (
-    "CLAUDE.md",
-    "RULES.md",
-)
-default_python_version = "3.13"
-
-
-@t.runtime_checkable
-class CommandRunner(t.Protocol):
-    def execute_command(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]: ...
-
-
-@t.runtime_checkable
-class OptionsProtocol(t.Protocol):
-    commit: bool
-    interactive: bool
-    no_config_updates: bool
-    verbose: bool
-    update_precommit: bool
-    update_docs: bool
-    force_update_docs: bool
-    compress_docs: bool
-    clean: bool
-    test: bool
-    benchmark: bool
-    benchmark_regression: bool
-    benchmark_regression_threshold: float
-    test_workers: int = 0
-    test_timeout: int = 0
-    publish: t.Any | None
-    bump: t.Any | None
-    all: t.Any | None
-    ai_agent: bool = False
-    create_pr: bool = False
-    skip_hooks: bool = False
-    comprehensive: bool = False
-    async_mode: bool = False
-    track_progress: bool = False
-    resume_from: str | None = None
-    progress_file: str | None = None
-
-
-class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
-    console: Console
-
-    def _analyze_workload_characteristics(self, files: list[Path]) -> dict[str, t.Any]:
-        if not files:
-            return {
-                "total_files": 0,
-                "total_size": 0,
-                "avg_file_size": 0,
-                "complexity": "low",
-            }
-        total_size = 0
-        large_files = 0
-        for file_path in files:
-            try:
-                size = file_path.stat().st_size
-                total_size += size
-                if size > 50_000:
-                    large_files += 1
-            except (OSError, PermissionError):
-                continue
-        avg_file_size = total_size / len(files) if files else 0
-        large_file_ratio = large_files / len(files) if files else 0
-        if len(files) > 100 or avg_file_size > 20_000 or large_file_ratio > 0.3:
-            complexity = "high"
-        elif len(files) > 50 or avg_file_size > 10_000 or large_file_ratio > 0.1:
-            complexity = "medium"
-        else:
-            complexity = "low"
-
-        return {
-            "total_files": len(files),
-            "total_size": total_size,
-            "avg_file_size": avg_file_size,
-            "large_files": large_files,
-            "large_file_ratio": large_file_ratio,
-            "complexity": complexity,
-        }
-
-    def _calculate_optimal_workers(self, workload: dict[str, t.Any]) -> int:
-        import os
-
-        cpu_count = os.cpu_count() or 4
-        if workload["complexity"] == "high":
-            max_workers = min(cpu_count // 2, 3)
-        elif workload["complexity"] == "medium":
-            max_workers = min(cpu_count, 6)
-        else:
-            max_workers = min(cpu_count + 2, 8)
-
-        return min(max_workers, workload["total_files"])
-
-    def clean_files(self, pkg_dir: Path | None) -> None:
-        if pkg_dir is None:
-            return
-        python_files = [
-            file_path
-            for file_path in pkg_dir.rglob("*.py")
-            if not str(file_path.parent).startswith("__")
-        ]
-        if not python_files:
-            return
-        workload = self._analyze_workload_characteristics(python_files)
-        max_workers = self._calculate_optimal_workers(workload)
-        if len(python_files) > 10:
-            self.console.print(
-                f"[dim]Cleaning {workload['total_files']} files "
-                f"({workload['complexity']} complexity) with {max_workers} workers[/dim]"
-            )
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_file = {
-                executor.submit(self.clean_file, file_path): file_path
-                for file_path in python_files
-            }
-            for future in as_completed(future_to_file):
-                file_path = future_to_file[future]
-                try:
-                    future.result()
-                except Exception as e:
-                    self.console.print(
-                        f"[bold bright_red]❌ Error cleaning {file_path}: {e}[/bold bright_red]"
-                    )
-        self._cleanup_cache_directories(pkg_dir)
-
-    def _cleanup_cache_directories(self, pkg_dir: Path) -> None:
-        with suppress(PermissionError, OSError):
-            pycache_dir = pkg_dir / "__pycache__"
-            if pycache_dir.exists():
-                for cache_file in pycache_dir.iterdir():
-                    with suppress(PermissionError, OSError):
-                        cache_file.unlink()
-                pycache_dir.rmdir()
-            parent_pycache = pkg_dir.parent / "__pycache__"
-            if parent_pycache.exists():
-                for cache_file in parent_pycache.iterdir():
-                    with suppress(PermissionError, OSError):
-                        cache_file.unlink()
-                parent_pycache.rmdir()
-
-    def clean_file(self, file_path: Path) -> None:
-        from crackerjack.errors import ExecutionError, handle_error
-
-        try:
-            code = file_path.read_text(encoding="utf-8")
-            original_code = code
-            cleaning_failed = False
-            try:
-                code = self.remove_line_comments_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove line comments from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = self.remove_docstrings_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove docstrings from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = self.remove_extra_whitespace_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove extra whitespace from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = self.reformat_code(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to reformat {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            file_path.write_text(code, encoding="utf-8")
-            if cleaning_failed:
-                self.console.print(
-                    f"[bold yellow]⚡ Partially cleaned:[/bold yellow] [dim bright_white]{file_path}[/dim bright_white]"
-                )
-            else:
-                self.console.print(
-                    f"[bold green]✨ Cleaned:[/bold green] [dim bright_white]{file_path}[/dim bright_white]"
-                )
-        except PermissionError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (Permission denied)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"Permission denied while cleaning {file_path}",
-                    error_code=ErrorCode.PERMISSION_ERROR,
-                    details=str(e),
-                    recovery=f"Check file permissions for {file_path} and ensure you have write access",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except OSError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (File system error)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"File system error while cleaning {file_path}",
-                    error_code=ErrorCode.FILE_WRITE_ERROR,
-                    details=str(e),
-                    recovery=f"Check that {file_path} exists and is not being used by another process",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except UnicodeDecodeError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (Encoding error)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"Encoding error while reading {file_path}",
-                    error_code=ErrorCode.FILE_READ_ERROR,
-                    details=str(e),
-                    recovery=f"File {file_path} contains non-UTF-8 characters. Please check the file encoding.",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except Exception as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (Unexpected error)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"Unexpected error while cleaning {file_path}",
-                    error_code=ErrorCode.UNEXPECTED_ERROR,
-                    details=str(e),
-                    recovery="This is an unexpected error. Please report this issue with the file content if possible.",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-
-    def _initialize_docstring_state(self) -> dict[str, t.Any]:
-        return {
-            "in_docstring": False,
-            "delimiter": None,
-            "waiting": False,
-            "function_indent": 0,
-            "removed_docstring": False,
-            "in_multiline_def": False,
-        }
-
-    def _handle_function_definition(
-        self, line: str, stripped: str, state: dict[str, t.Any]
-    ) -> bool:
-        if self._is_function_or_class_definition(stripped):
-            state["waiting"] = True
-            state["function_indent"] = len(line) - len(line.lstrip())
-            state["removed_docstring"] = False
-            state["in_multiline_def"] = not stripped.endswith(":")
-            return True
-        return False
-
-    def _handle_multiline_definition(
-        self, line: str, stripped: str, state: dict[str, t.Any]
-    ) -> bool:
-        if state["in_multiline_def"]:
-            if stripped.endswith(":"):
-                state["in_multiline_def"] = False
-            return True
-        return False
-
-    def _handle_waiting_docstring(
-        self, lines: list[str], i: int, stripped: str, state: dict[str, t.Any]
-    ) -> tuple[bool, str | None]:
-        if state["waiting"] and stripped:
-            if self._handle_docstring_start(stripped, state):
-                pass_line = None
-                if not state["in_docstring"]:
-                    function_indent: int = state["function_indent"]
-                    if self._needs_pass_statement(lines, i + 1, function_indent):
-                        pass_line = " " * (function_indent + 4) + "pass"
-                state["removed_docstring"] = True
-                return True, pass_line
-            else:
-                state["waiting"] = False
-        return False, None
-
-    def _handle_docstring_content(
-        self, lines: list[str], i: int, stripped: str, state: dict[str, t.Any]
-    ) -> tuple[bool, str | None]:
-        if state["in_docstring"]:
-            if self._handle_docstring_end(stripped, state):
-                pass_line = None
-                function_indent: int = state["function_indent"]
-                if self._needs_pass_statement(lines, i + 1, function_indent):
-                    pass_line = " " * (function_indent + 4) + "pass"
-                state["removed_docstring"] = False
-                return True, pass_line
-            else:
-                return True, None
-        return False, None
-
-    def _process_line(
-        self, lines: list[str], i: int, line: str, state: dict[str, t.Any]
-    ) -> tuple[bool, str | None]:
-        stripped = line.strip()
-        if self._handle_function_definition(line, stripped, state):
-            return True, line
-        if self._handle_multiline_definition(line, stripped, state):
-            return True, line
-        handled, pass_line = self._handle_waiting_docstring(lines, i, stripped, state)
-        if handled:
-            return True, pass_line
-        handled, pass_line = self._handle_docstring_content(lines, i, stripped, state)
-        if handled:
-            return True, pass_line
-        if state["removed_docstring"] and stripped:
-            state["removed_docstring"] = False
-        return False, line
-
-    def remove_docstrings(self, code: str) -> str:
-        lines = code.split("\n")
-        cleaned_lines: list[str] = []
-        docstring_state = self._initialize_docstring_state()
-        for i, line in enumerate(lines):
-            handled, result_line = self._process_line(lines, i, line, docstring_state)
-            if handled:
-                if result_line is not None:
-                    cleaned_lines.append(result_line)
-            else:
-                cleaned_lines.append(line)
-        return "\n".join(cleaned_lines)
-
-    def _is_function_or_class_definition(self, stripped_line: str) -> bool:
-        return stripped_line.startswith(("def ", "class ", "async def "))
-
-    def _handle_docstring_start(self, stripped: str, state: dict[str, t.Any]) -> bool:
-        if not stripped.startswith(('"""', "'''", '"', "'")):
-            return False
-        if stripped.startswith(('"""', "'''")):
-            delimiter = stripped[:3]
-        else:
-            delimiter = stripped[0]
-        state["delimiter"] = delimiter
-        if self._is_single_line_docstring(stripped, delimiter):
-            state["waiting"] = False
-            return True
-        else:
-            state["in_docstring"] = True
-            state["waiting"] = False
-            return True
-
-    def _is_single_line_docstring(self, stripped: str, delimiter: str) -> bool:
-        return stripped.endswith(delimiter) and len(stripped) > len(delimiter)
-
-    def _handle_docstring_end(self, stripped: str, state: dict[str, t.Any]) -> bool:
-        if state["delimiter"] and stripped.endswith(state["delimiter"]):
-            state["in_docstring"] = False
-            state["delimiter"] = None
-            return True
-        return False
-
-    def _needs_pass_statement(
-        self, lines: list[str], start_index: int, function_indent: int
-    ) -> bool:
-        for i in range(start_index, len(lines)):
-            line = lines[i]
-            stripped = line.strip()
-            if not stripped:
-                continue
-            line_indent = len(line) - len(line.lstrip())
-            if line_indent <= function_indent:
-                return True
-            if line_indent > function_indent:
-                return False
-        return True
-
-    def remove_line_comments(self, code: str) -> str:
-        lines = code.split("\n")
-        cleaned_lines: list[str] = []
-        for line in lines:
-            if not line.strip():
-                cleaned_lines.append(line)
-                continue
-            cleaned_line = self._process_line_for_comments(line)
-            if cleaned_line or not line.strip():
-                cleaned_lines.append(cleaned_line or line)
-        return "\n".join(cleaned_lines)
-
-    def _process_line_for_comments(self, line: str) -> str:
-        result: list[str] = []
-        string_state = {"in_string": None}
-        for i, char in enumerate(line):
-            if self._handle_string_character(char, i, line, string_state, result):
-                continue
-            elif self._handle_comment_character(char, i, line, string_state, result):
-                break
-            else:
-                result.append(char)
-        return "".join(result).rstrip()
-
-    def _handle_string_character(
-        self,
-        char: str,
-        index: int,
-        line: str,
-        string_state: dict[str, t.Any],
-        result: list[str],
-    ) -> bool:
-        if char not in ("'", '"'):
-            return False
-        if index > 0 and line[index - 1] == "\\":
-            return False
-        if string_state["in_string"] is None:
-            string_state["in_string"] = char
-        elif string_state["in_string"] == char:
-            string_state["in_string"] = None
-        result.append(char)
-        return True
-
-    def _handle_comment_character(
-        self,
-        char: str,
-        index: int,
-        line: str,
-        string_state: dict[str, t.Any],
-        result: list[str],
-    ) -> bool:
-        if char != "#" or string_state["in_string"] is not None:
-            return False
-        comment = line[index:].strip()
-        if self._is_special_comment_line(comment):
-            result.append(line[index:])
-        return True
-
-    def _is_special_comment_line(self, comment: str) -> bool:
-        special_comment_pattern = (
-            r"^#\s*(?:type:\s*ignore(?:\[.*?\])?|noqa|nosec|pragma:\s*no\s*cover"
-            r"|pylint:\s*disable|mypy:\s*ignore)"
-        )
-        return bool(re.match(special_comment_pattern, comment))
-
-    def remove_extra_whitespace(self, code: str) -> str:
-        lines = code.split("\n")
-        cleaned_lines: list[str] = []
-        function_tracker = {"in_function": False, "function_indent": 0}
-        import_tracker = {"in_imports": False, "last_import_type": None}
-        for i, line in enumerate(lines):
-            line = line.rstrip()
-            stripped_line = line.lstrip()
-            self._update_function_state(line, stripped_line, function_tracker)
-            self._update_import_state(line, stripped_line, import_tracker)
-            if not line:
-                if self._should_skip_empty_line(
-                    i, lines, cleaned_lines, function_tracker, import_tracker
-                ):
-                    continue
-            cleaned_lines.append(line)
-        return "\n".join(self._remove_trailing_empty_lines(cleaned_lines))
-
-    def remove_docstrings_streaming(self, code: str) -> str:
-        if len(code) < 10000:
-            return self.remove_docstrings(code)
-
-        def process_lines():
-            lines = code.split("\n")
-            docstring_state = self._initialize_docstring_state()
-            for i, line in enumerate(lines):
-                handled, result_line = self._process_line(
-                    lines, i, line, docstring_state
-                )
-                if handled:
-                    if result_line is not None:
-                        yield result_line
-                else:
-                    yield line
-
-        return "\n".join(process_lines())
-
-    def remove_line_comments_streaming(self, code: str) -> str:
-        if len(code) < 10000:
-            return self.remove_line_comments(code)
-
-        def process_lines():
-            for line in code.split("\n"):
-                if not line.strip():
-                    yield line
-                    continue
-                cleaned_line = self._process_line_for_comments(line)
-                if cleaned_line or not line.strip():
-                    yield cleaned_line or line
-
-        return "\n".join(process_lines())
-
-    def remove_extra_whitespace_streaming(self, code: str) -> str:
-        if len(code) < 10000:
-            return self.remove_extra_whitespace(code)
-
-        def process_lines():
-            lines = code.split("\n")
-            function_tracker: dict[str, t.Any] = {
-                "in_function": False,
-                "function_indent": 0,
-            }
-            import_tracker: dict[str, t.Any] = {
-                "in_imports": False,
-                "last_import_type": None,
-            }
-            previous_lines: list[str] = []
-            for i, line in enumerate(lines):
-                line = line.rstrip()
-                stripped_line = line.lstrip()
-                self._update_function_state(line, stripped_line, function_tracker)
-                self._update_import_state(line, stripped_line, import_tracker)
-                if not line:
-                    if self._should_skip_empty_line(
-                        i, lines, previous_lines, function_tracker, import_tracker
-                    ):
-                        continue
-                previous_lines.append(line)
-                yield line
-
-        processed_lines = list(process_lines())
-        return "\n".join(self._remove_trailing_empty_lines(processed_lines))
-
-    def _update_function_state(
-        self, line: str, stripped_line: str, function_tracker: dict[str, t.Any]
-    ) -> None:
-        if stripped_line.startswith(("def ", "async def ")):
-            function_tracker["in_function"] = True
-            function_tracker["function_indent"] = len(line) - len(stripped_line)
-        elif self._is_function_end(line, stripped_line, function_tracker):
-            function_tracker["in_function"] = False
-            function_tracker["function_indent"] = 0
-
-    def _update_import_state(
-        self, line: str, stripped_line: str, import_tracker: dict[str, t.Any]
-    ) -> None:
-        if stripped_line.startswith(("import ", "from ")):
-            import_tracker["in_imports"] = True
-            if self._is_stdlib_import(stripped_line):
-                current_type = "stdlib"
-            elif self._is_local_import(stripped_line):
-                current_type = "local"
-            else:
-                current_type = "third_party"
-            import_tracker["last_import_type"] = current_type
-        elif stripped_line and not stripped_line.startswith("#"):
-            import_tracker["in_imports"] = False
-            import_tracker["last_import_type"] = None
-
-    @staticmethod
-    @lru_cache(maxsize=256)
-    def _is_stdlib_module(module: str) -> bool:
-        stdlib_modules = {
-            "os",
-            "sys",
-            "re",
-            "json",
-            "datetime",
-            "time",
-            "pathlib",
-            "typing",
-            "collections",
-            "itertools",
-            "functools",
-            "operator",
-            "math",
-            "random",
-            "uuid",
-            "urllib",
-            "http",
-            "html",
-            "xml",
-            "email",
-            "csv",
-            "sqlite3",
-            "subprocess",
-            "threading",
-            "multiprocessing",
-            "asyncio",
-            "contextlib",
-            "dataclasses",
-            "enum",
-            "abc",
-            "io",
-            "tempfile",
-            "shutil",
-            "glob",
-            "pickle",
-            "copy",
-            "heapq",
-            "bisect",
-            "array",
-            "struct",
-            "zlib",
-            "hashlib",
-            "hmac",
-            "secrets",
-            "base64",
-            "binascii",
-            "codecs",
-            "locale",
-            "platform",
-            "socket",
-            "ssl",
-            "ipaddress",
-            "logging",
-            "warnings",
-            "inspect",
-            "ast",
-            "dis",
-            "tokenize",
-            "keyword",
-            "linecache",
-            "traceback",
-            "weakref",
-            "gc",
-            "ctypes",
-            "unittest",
-            "doctest",
-            "pdb",
-            "profile",
-            "cProfile",
-            "timeit",
-            "trace",
-            "calendar",
-            "decimal",
-            "fractions",
-            "statistics",
-            "tomllib",
-        }
-        return module in stdlib_modules
-
-    def _is_stdlib_import(self, stripped_line: str) -> bool:
-        try:
-            if stripped_line.startswith("from "):
-                module = stripped_line.split()[1].split(".")[0]
-            else:
-                module = stripped_line.split()[1].split(".")[0]
-        except IndexError:
-            return False
-        return CodeCleaner._is_stdlib_module(module)
-
-    def _is_local_import(self, stripped_line: str) -> bool:
-        return stripped_line.startswith("from .") or " . " in stripped_line
-
-    def _is_function_end(
-        self, line: str, stripped_line: str, function_tracker: dict[str, t.Any]
-    ) -> bool:
-        return (
-            function_tracker["in_function"]
-            and bool(line)
-            and (len(line) - len(stripped_line) <= function_tracker["function_indent"])
-            and (not stripped_line.startswith(("@", "#")))
-        )
-
-    def _should_skip_empty_line(
-        self,
-        line_idx: int,
-        lines: list[str],
-        cleaned_lines: list[str],
-        function_tracker: dict[str, t.Any],
-        import_tracker: dict[str, t.Any],
-    ) -> bool:
-        if line_idx > 0 and cleaned_lines and (not cleaned_lines[-1]):
-            return True
-
-        if self._is_import_section_separator(line_idx, lines, import_tracker):
-            return False
-
-        if function_tracker["in_function"]:
-            return self._should_skip_function_empty_line(line_idx, lines)
-        return False
-
-    def _is_import_section_separator(
-        self, line_idx: int, lines: list[str], import_tracker: dict[str, t.Any]
-    ) -> bool:
-        if not import_tracker["in_imports"]:
-            return False
-
-        next_line_idx = line_idx + 1
-        while next_line_idx < len(lines) and not lines[next_line_idx].strip():
-            next_line_idx += 1
-
-        if next_line_idx >= len(lines):
-            return False
-
-        next_line = lines[next_line_idx].strip()
-        if not next_line.startswith(("import ", "from ")):
-            return False
-
-        if self._is_stdlib_import(next_line):
-            next_type = "stdlib"
-        elif self._is_local_import(next_line):
-            next_type = "local"
-        else:
-            next_type = "third_party"
-
-        return import_tracker["last_import_type"] != next_type
-
-    def _should_skip_function_empty_line(self, line_idx: int, lines: list[str]) -> bool:
-        next_line_idx = line_idx + 1
-        if next_line_idx >= len(lines):
-            return False
-        next_line = lines[next_line_idx].strip()
-        return not self._is_significant_next_line(next_line)
-
-    def _is_significant_next_line(self, next_line: str) -> bool:
-        if next_line.startswith(("return", "class ", "def ", "async def ", "@")):
-            return True
-        if next_line in ("pass", "break", "continue", "raise"):
-            return True
-        return self._is_special_comment(next_line)
-
-    def _is_special_comment(self, line: str) -> bool:
-        if not line.startswith("#"):
-            return False
-        special_patterns = ("type:", "noqa", "nosec", "pragma:", "pylint:", "mypy:")
-        return any(pattern in line for pattern in special_patterns)
-
-    def _remove_trailing_empty_lines(self, lines: list[str]) -> list[str]:
-        while lines and (not lines[-1]):
-            lines.pop()
-        return lines
-
-    def reformat_code(self, code: str) -> str:
-        from crackerjack.errors import handle_error
-
-        try:
-            import tempfile
-
-            with tempfile.NamedTemporaryFile(
-                suffix=".py", mode="w+", delete=False
-            ) as temp:
-                temp_path = Path(temp.name)
-                temp_path.write_text(code)
-            try:
-                result = subprocess.run(
-                    ["uv", "run", "ruff", "format", str(temp_path)],
-                    check=False,
-                    capture_output=True,
-                    text=True,
-                )
-                if result.returncode == 0:
-                    formatted_code = temp_path.read_text()
-                else:
-                    self.console.print(
-                        f"[bold bright_yellow]⚠️  Ruff formatting failed: {result.stderr}[/bold bright_yellow]"
-                    )
-                    handle_error(
-                        ExecutionError(
-                            message="Code formatting failed",
-                            error_code=ErrorCode.FORMATTING_ERROR,
-                            details=result.stderr,
-                            recovery="Check Ruff configuration and formatting rules",
-                        ),
-                        console=self.console,
-                        exit_on_error=False,
-                    )
-                    formatted_code = code
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_red]❌ Error running Ruff: {e}[/bold bright_red]"
-                )
-                handle_error(
-                    ExecutionError(
-                        message="Error running Ruff",
-                        error_code=ErrorCode.FORMATTING_ERROR,
-                        details=str(e),
-                        recovery="Verify Ruff is installed and configured correctly",
-                    ),
-                    console=self.console,
-                    exit_on_error=False,
-                )
-                formatted_code = code
-            finally:
-                with suppress(FileNotFoundError):
-                    temp_path.unlink()
-            return formatted_code
-        except Exception as e:
-            self.console.print(
-                f"[bold bright_red]❌ Error during reformatting: {e}[/bold bright_red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message="Error during reformatting",
-                    error_code=ErrorCode.FORMATTING_ERROR,
-                    details=str(e),
-                    recovery="Check file permissions and disk space",
-                ),
-                console=self.console,
-            )
-            return code
-
-    async def clean_files_async(self, pkg_dir: Path | None) -> None:
-        if pkg_dir is None:
-            return
-        python_files = [
-            file_path
-            for file_path in pkg_dir.rglob("*.py")
-            if not str(file_path.parent).startswith("__")
-        ]
-        if not python_files:
-            return
-        max_concurrent = min(len(python_files), 8)
-        semaphore = asyncio.Semaphore(max_concurrent)
-
-        async def clean_with_semaphore(file_path: Path) -> None:
-            async with semaphore:
-                await self.clean_file_async(file_path)
-
-        tasks = [clean_with_semaphore(file_path) for file_path in python_files]
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-        await self._cleanup_cache_directories_async(pkg_dir)
-
-    async def clean_file_async(self, file_path: Path) -> None:
-        from crackerjack.errors import ExecutionError, handle_error
-
-        try:
-            async with aiofiles.open(file_path, encoding="utf-8") as f:  # type: ignore[misc]
-                code: str = await f.read()  # type: ignore[misc]
-            original_code: str = code
-            cleaning_failed = False
-            try:
-                code = self.remove_line_comments_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove line comments from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = self.remove_docstrings_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove docstrings from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = self.remove_extra_whitespace_streaming(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to remove extra whitespace from {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            try:
-                code = await self.reformat_code_async(code)
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_yellow]⚠️  Warning: Failed to reformat {file_path}: {e}[/bold bright_yellow]"
-                )
-                code = original_code
-                cleaning_failed = True
-            async with aiofiles.open(file_path, "w", encoding="utf-8") as f:  # type: ignore[misc]
-                await f.write(code)  # type: ignore[misc]
-            if cleaning_failed:
-                self.console.print(
-                    f"[bold yellow]⚡ Partially cleaned:[/bold yellow] [dim bright_white]{file_path}[/dim bright_white]"
-                )
-            else:
-                self.console.print(
-                    f"[bold green]✨ Cleaned:[/bold green] [dim bright_white]{file_path}[/dim bright_white]"
-                )
-        except PermissionError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (Permission denied)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"Permission denied while cleaning {file_path}",
-                    error_code=ErrorCode.PERMISSION_ERROR,
-                    details=str(e),
-                    recovery=f"Check file permissions for {file_path} and ensure you have write access",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except OSError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (File system error)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"File system error while cleaning {file_path}",
-                    error_code=ErrorCode.FILE_WRITE_ERROR,
-                    details=str(e),
-                    recovery=f"Check that {file_path} exists and is not being used by another process",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except UnicodeDecodeError as e:
-            self.console.print(
-                f"[red]Failed to clean: {file_path} (Encoding error)[/red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message=f"Encoding error while cleaning {file_path}",
-                    error_code=ErrorCode.FILE_READ_ERROR,
-                    details=str(e),
-                    recovery=f"Check the file encoding of {file_path} - it may not be UTF-8",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-        except Exception as e:
-            self.console.print(f"[red]Unexpected error cleaning {file_path}: {e}[/red]")
-            handle_error(
-                ExecutionError(
-                    message=f"Unexpected error while cleaning {file_path}",
-                    error_code=ErrorCode.UNEXPECTED_ERROR,
-                    details=str(e),
-                    recovery="Please report this issue with the full error details",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-
-    async def reformat_code_async(self, code: str) -> str:
-        from crackerjack.errors import handle_error
-
-        try:
-            import tempfile
-
-            with tempfile.NamedTemporaryFile(
-                suffix=".py", mode="w+", delete=False
-            ) as temp:
-                temp_path = Path(temp.name)
-            async with aiofiles.open(temp_path, "w", encoding="utf-8") as f:  # type: ignore[misc]
-                await f.write(code)  # type: ignore[misc]
-            try:
-                proc = await asyncio.create_subprocess_exec(
-                    "uv",
-                    "run",
-                    "ruff",
-                    "format",
-                    str(temp_path),
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                )
-                _, stderr = await proc.communicate()
-                if proc.returncode == 0:
-                    async with aiofiles.open(temp_path, encoding="utf-8") as f:  # type: ignore[misc]
-                        formatted_code = await f.read()  # type: ignore[misc]
-                else:
-                    self.console.print(
-                        f"[bold bright_yellow]⚠️  Warning: Ruff format failed with return code {proc.returncode}[/bold bright_yellow]"
-                    )
-                    if stderr:
-                        self.console.print(f"[dim]Ruff stderr: {stderr.decode()}[/dim]")
-                    formatted_code = code
-            except Exception as e:
-                self.console.print(
-                    f"[bold bright_red]❌ Error running Ruff: {e}[/bold bright_red]"
-                )
-                handle_error(
-                    ExecutionError(
-                        message="Error running Ruff",
-                        error_code=ErrorCode.FORMATTING_ERROR,
-                        details=str(e),
-                        recovery="Verify Ruff is installed and configured correctly",
-                    ),
-                    console=self.console,
-                    exit_on_error=False,
-                )
-                formatted_code = code
-            finally:
-                with suppress(FileNotFoundError):
-                    temp_path.unlink()
-
-            return formatted_code
-        except Exception as e:
-            self.console.print(
-                f"[bold bright_red]❌ Error during reformatting: {e}[/bold bright_red]"
-            )
-            handle_error(
-                ExecutionError(
-                    message="Error during reformatting",
-                    error_code=ErrorCode.FORMATTING_ERROR,
-                    details=str(e),
-                    recovery="Check file permissions and disk space",
-                ),
-                console=self.console,
-                exit_on_error=False,
-            )
-            return code
-
-    async def _cleanup_cache_directories_async(self, pkg_dir: Path) -> None:
-        def cleanup_sync() -> None:
-            with suppress(PermissionError, OSError):
-                pycache_dir = pkg_dir / "__pycache__"
-                if pycache_dir.exists():
-                    for cache_file in pycache_dir.iterdir():
-                        with suppress(PermissionError, OSError):
-                            cache_file.unlink()
-                    pycache_dir.rmdir()
-                parent_pycache = pkg_dir.parent / "__pycache__"
-                if parent_pycache.exists():
-                    for cache_file in parent_pycache.iterdir():
-                        with suppress(PermissionError, OSError):
-                            cache_file.unlink()
-                    parent_pycache.rmdir()
-
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, cleanup_sync)
-
-
-class ConfigManager(BaseModel, arbitrary_types_allowed=True):
-    our_path: Path
-    pkg_path: Path
-    pkg_name: str
-    console: Console
-    our_toml_path: Path | None = None
-    pkg_toml_path: Path | None = None
-    python_version: str = default_python_version
-    dry_run: bool = False
-
-    def swap_package_name(self, value: list[str] | str) -> list[str] | str:
-        if isinstance(value, list):
-            value.remove("crackerjack")
-            value.append(self.pkg_name)
-        else:
-            value = value.replace("crackerjack", self.pkg_name)
-        return value
-
-    def update_pyproject_configs(self) -> None:
-        self._setup_toml_paths()
-        if self._is_crackerjack_project():
-            self._handle_crackerjack_project()
-            return
-        our_toml_config = self._load_our_toml()
-        pkg_toml_config = self._load_pkg_toml()
-        self._ensure_required_sections(pkg_toml_config)
-        self._update_tool_settings(our_toml_config, pkg_toml_config)
-        self._update_python_version(our_toml_config, pkg_toml_config)
-        self._save_pkg_toml(pkg_toml_config)
-
-    def _setup_toml_paths(self) -> None:
-        toml_file = "pyproject.toml"
-        self.our_toml_path = self.our_path / toml_file
-        self.pkg_toml_path = self.pkg_path / toml_file
-
-    def _is_crackerjack_project(self) -> bool:
-        return self.pkg_path.stem == "crackerjack"
-
-    def _handle_crackerjack_project(self) -> None:
-        if self.our_toml_path and self.pkg_toml_path:
-            self.our_toml_path.write_text(self.pkg_toml_path.read_text())
-
-    def _load_our_toml(self) -> dict[str, t.Any]:
-        if self.our_toml_path:
-            return loads(self.our_toml_path.read_text())
-        return {}
-
-    def _load_pkg_toml(self) -> dict[str, t.Any]:
-        if self.pkg_toml_path:
-            return loads(self.pkg_toml_path.read_text())
-        return {}
-
-    def _ensure_required_sections(self, pkg_toml_config: dict[str, t.Any]) -> None:
-        pkg_toml_config.setdefault("tool", {})
-        pkg_toml_config.setdefault("project", {})
-
-    def _update_tool_settings(
-        self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
-    ) -> None:
-        for tool, settings in our_toml_config.get("tool", {}).items():
-            if tool not in pkg_toml_config["tool"]:
-                pkg_toml_config["tool"][tool] = {}
-            pkg_tool_config = pkg_toml_config["tool"][tool]
-            self._merge_tool_config(settings, pkg_tool_config, tool)
-
-    def _merge_tool_config(
-        self, our_config: dict[str, t.Any], pkg_config: dict[str, t.Any], tool: str
-    ) -> None:
-        for setting, value in our_config.items():
-            if isinstance(value, dict):
-                self._merge_nested_config(
-                    setting, t.cast(dict[str, t.Any], value), pkg_config
-                )
-            else:
-                self._merge_direct_config(setting, value, pkg_config)
-
-    def _merge_nested_config(
-        self, setting: str, value: dict[str, t.Any], pkg_config: dict[str, t.Any]
-    ) -> None:
-        if setting not in pkg_config:
-            pkg_config[setting] = {}
-        elif not isinstance(pkg_config[setting], dict):
-            pkg_config[setting] = {}
-        self._merge_tool_config(value, pkg_config[setting], "")
-        for k, v in value.items():
-            self._merge_nested_value(k, v, pkg_config[setting])
-
-    def _merge_nested_value(
-        self, key: str, value: t.Any, nested_config: dict[str, t.Any]
-    ) -> None:
-        if isinstance(value, str | list) and "crackerjack" in str(value):
-            nested_config[key] = self.swap_package_name(t.cast(str | list[str], value))
-        elif self._is_mergeable_list(key, value):
-            existing = nested_config.get(key, [])
-            if isinstance(existing, list) and isinstance(value, list):
-                nested_config[key] = list(
-                    set(t.cast(list[str], existing) + t.cast(list[str], value))
-                )
-            else:
-                nested_config[key] = value
-        elif key not in nested_config:
-            nested_config[key] = value
-
-    def _merge_direct_config(
-        self, setting: str, value: t.Any, pkg_config: dict[str, t.Any]
-    ) -> None:
-        if isinstance(value, str | list) and "crackerjack" in str(value):
-            pkg_config[setting] = self.swap_package_name(t.cast(str | list[str], value))
-        elif self._is_mergeable_list(setting, value):
-            existing = pkg_config.get(setting, [])
-            if isinstance(existing, list) and isinstance(value, list):
-                pkg_config[setting] = list(
-                    set(t.cast(list[str], existing) + t.cast(list[str], value))
-                )
-            else:
-                pkg_config[setting] = value
-        elif setting not in pkg_config:
-            pkg_config[setting] = value
-
-    def _is_mergeable_list(self, key: str, value: t.Any) -> bool:
-        return key in (
-            "exclude-deps",
-            "exclude",
-            "excluded",
-            "skips",
-            "ignore",
-        ) and isinstance(value, list)
-
-    def _update_python_version(
-        self, our_toml_config: dict[str, t.Any], pkg_toml_config: dict[str, t.Any]
-    ) -> None:
-        python_version_pattern = "\\s*W*(\\d\\.\\d*)"
-        requires_python = our_toml_config.get("project", {}).get("requires-python", "")
-        classifiers: list[str] = []
-        for classifier in pkg_toml_config.get("project", {}).get("classifiers", []):
-            classifier = re.sub(
-                python_version_pattern, f" {self.python_version}", classifier
-            )
-            classifiers.append(classifier)
-        pkg_toml_config["project"]["classifiers"] = classifiers
-        if requires_python:
-            pkg_toml_config["project"]["requires-python"] = requires_python
-
-    def _save_pkg_toml(self, pkg_toml_config: dict[str, t.Any]) -> None:
-        if self.pkg_toml_path:
-            self.pkg_toml_path.write_text(dumps(pkg_toml_config))
-
-    def copy_configs(self) -> None:
-        configs_to_add: list[str] = []
-        for config in config_files:
-            config_path = self.our_path / config
-            pkg_config_path = self.pkg_path / config
-            pkg_config_path.touch()
-            if self.pkg_path.stem == "crackerjack":
-                config_path.write_text(pkg_config_path.read_text())
-                continue
-            if config != ".gitignore":
-                pkg_config_path.write_text(
-                    config_path.read_text().replace("crackerjack", self.pkg_name)
-                )
-                configs_to_add.append(config)
-        if configs_to_add:
-            self.execute_command(["git", "add"] + configs_to_add)
-
-    def copy_documentation_templates(
-        self, force_update: bool = False, compress_docs: bool = False
-    ) -> None:
-        docs_to_add: list[str] = []
-        for doc_file in documentation_files:
-            if self._should_process_doc_file(doc_file):
-                self._process_single_doc_file(
-                    doc_file, force_update, compress_docs, docs_to_add
-                )
-
-        if docs_to_add:
-            self.execute_command(["git", "add"] + docs_to_add)
-
-    def _should_process_doc_file(self, doc_file: str) -> bool:
-        doc_path = self.our_path / doc_file
-        if not doc_path.exists():
-            return False
-        if self.pkg_path.stem == "crackerjack":
-            return False
-        return True
-
-    def _process_single_doc_file(
-        self,
-        doc_file: str,
-        force_update: bool,
-        compress_docs: bool,
-        docs_to_add: list[str],
-    ) -> None:
-        doc_path = self.our_path / doc_file
-        pkg_doc_path = self.pkg_path / doc_file
-        should_update = force_update or not pkg_doc_path.exists()
-
-        if should_update:
-            pkg_doc_path.touch()
-            content = doc_path.read_text(encoding="utf-8")
-
-            auto_compress = self._should_compress_doc(doc_file, compress_docs)
-            updated_content = self._customize_documentation_content(
-                content, doc_file, auto_compress
-            )
-            pkg_doc_path.write_text(updated_content, encoding="utf-8")
-            docs_to_add.append(doc_file)
-
-            self._print_doc_update_message(doc_file, auto_compress)
-
-    def _should_compress_doc(self, doc_file: str, compress_docs: bool) -> bool:
-        return compress_docs or (
-            self.pkg_path.stem != "crackerjack" and doc_file == "CLAUDE.md"
-        )
-
-    def _print_doc_update_message(self, doc_file: str, auto_compress: bool) -> None:
-        compression_note = (
-            " (compressed for Claude Code)"
-            if auto_compress and doc_file == "CLAUDE.md"
-            else ""
-        )
-        self.console.print(
-            f"[green]📋[/green] Updated {doc_file} with latest Crackerjack quality standards{compression_note}"
-        )
-
-    def _customize_documentation_content(
-        self, content: str, filename: str, compress: bool = False
-    ) -> str:
-        if filename == "CLAUDE.md":
-            return self._customize_claude_md(content, compress)
-        elif filename == "RULES.md":
-            return self._customize_rules_md(content)
-        return content
-
-    def _compress_claude_md(self, content: str, target_size: int = 30000) -> str:
-        content.split("\n")
-        current_size = len(content)
-        if current_size <= target_size:
-            return content
-        essential_sections = [
-            "# ",
-            "## Project Overview",
-            "## Key Commands",
-            "## Development Guidelines",
-            "## Code Quality Compliance",
-            "### Refurb Standards",
-            "### Bandit Security Standards",
-            "### Pyright Type Safety Standards",
-            "## AI Code Generation Best Practices",
-            "## Task Completion Requirements",
-        ]
-        compression_strategies = [
-            self._remove_redundant_examples,
-            self._compress_command_examples,
-            self._remove_verbose_sections,
-            self._compress_repeated_patterns,
-            self._summarize_long_sections,
-        ]
-        compressed_content = content
-        for strategy in compression_strategies:
-            compressed_content = strategy(compressed_content)
-            if len(compressed_content) <= target_size:
-                break
-        if len(compressed_content) > target_size:
-            compressed_content = self._extract_essential_sections(
-                compressed_content, essential_sections, target_size
-            )
-
-        return self._add_compression_notice(compressed_content)
-
-    def _remove_redundant_examples(self, content: str) -> str:
-        lines = content.split("\n")
-        result = []
-        in_example_block = False
-        example_count = 0
-        max_examples_per_section = 2
-        for line in lines:
-            if line.strip().startswith("```"):
-                if not in_example_block:
-                    example_count += 1
-                    if example_count <= max_examples_per_section:
-                        result.append(line)
-                        in_example_block = True
-                    else:
-                        in_example_block = "skip"
-                else:
-                    if in_example_block != "skip":
-                        result.append(line)
-                    in_example_block = False
-            elif in_example_block == "skip":
-                continue
-            elif line.startswith(("## ", "### ")):
-                example_count = 0
-                result.append(line)
-            else:
-                result.append(line)
-
-        return "\n".join(result)
-
-    def _compress_command_examples(self, content: str) -> str:
-        import re
-
-        content = re.sub(
-            r"```bash\n((?:[^`]+\n){3,})```",
-            lambda m: "```bash\n"
-            + "\n".join(m.group(1).split("\n")[:3])
-            + "\n# ... (additional commands available)\n```",
-            content,
-            flags=re.MULTILINE,
-        )
-
-        return content
-
-    def _remove_verbose_sections(self, content: str) -> str:
-        sections_to_compress = [
-            "## Recent Bug Fixes and Improvements",
-            "## Development Memories",
-            "## Self-Maintenance Protocol for AI Assistants",
-            "## Pre-commit Hook Maintenance",
-        ]
-        lines = content.split("\n")
-        result = []
-        skip_section = False
-        for line in lines:
-            if any(line.startswith(section) for section in sections_to_compress):
-                skip_section = True
-                result.extend(
-                    (line, "*[Detailed information available in full CLAUDE.md]*")
-                )
-                result.append("")
-            elif line.startswith("## ") and skip_section:
-                skip_section = False
-                result.append(line)
-            elif not skip_section:
-                result.append(line)
-
-        return "\n".join(result)
-
-    def _compress_repeated_patterns(self, content: str) -> str:
-        import re
-
-        content = re.sub(r"\n{3,}", "\n\n", content)
-        content = re.sub(
-            r"(\*\*[A-Z][^*]+:\*\*[^\n]+\n){3,}",
-            lambda m: m.group(0)[:200]
-            + "...\n*[Additional patterns available in full documentation]*\n",
-            content,
-        )
-
-        return content
-
-    def _summarize_long_sections(self, content: str) -> str:
-        lines = content.split("\n")
-        result = []
-        current_section = []
-        section_header = ""
-        for line in lines:
-            if line.startswith(("### ", "## ")):
-                if current_section and len("\n".join(current_section)) > 1000:
-                    summary = self._create_section_summary(
-                        section_header, current_section
-                    )
-                    result.extend(summary)
-                else:
-                    result.extend(current_section)
-                current_section = [line]
-                section_header = line
-            else:
-                current_section.append(line)
-        if current_section:
-            if len("\n".join(current_section)) > 1000:
-                summary = self._create_section_summary(section_header, current_section)
-                result.extend(summary)
-            else:
-                result.extend(current_section)
-
-        return "\n".join(result)
-
-    def _create_section_summary(
-        self, header: str, section_lines: list[str]
-    ) -> list[str]:
-        summary = [header, ""]
-
-        key_points = []
-        for line in section_lines[2:]:
-            if line.strip().startswith(("- ", "* ", "1. ", "2. ")):
-                key_points.append(line)
-            elif line.strip().startswith("**") and ":" in line:
-                key_points.append(line)
-
-            if len(key_points) >= 5:
-                break
-
-        if key_points:
-            summary.extend(key_points[:5])
-            summary.append("*[Complete details available in full CLAUDE.md]*")
-        else:
-            content_preview = " ".join(
-                line.strip()
-                for line in section_lines[2:10]
-                if line.strip() and not line.startswith("#")
-            )[:200]
-            summary.extend(
-                (
-                    f"{content_preview}...",
-                    "*[Full section available in complete documentation]*",
-                )
-            )
-
-        summary.append("")
-        return summary
-
-    def _extract_essential_sections(
-        self, content: str, essential_sections: list[str], target_size: int
-    ) -> str:
-        lines = content.split("\n")
-        result = []
-        current_section = []
-        keep_section = False
-
-        for line in lines:
-            new_section_started = self._process_line_for_section(
-                line, essential_sections, current_section, keep_section, result
-            )
-            if new_section_started is not None:
-                current_section, keep_section = new_section_started
-            else:
-                current_section.append(line)
-
-            if self._should_stop_extraction(result, target_size):
-                break
-
-        self._finalize_extraction(current_section, keep_section, result, target_size)
-        return "\n".join(result)
-
-    def _process_line_for_section(
-        self,
-        line: str,
-        essential_sections: list[str],
-        current_section: list[str],
-        keep_section: bool,
-        result: list[str],
-    ) -> tuple[list[str], bool] | None:
-        if any(line.startswith(section) for section in essential_sections):
-            if current_section and keep_section:
-                result.extend(current_section)
-            return ([line], True)
-        elif line.startswith(("## ", "### ")):
-            if current_section and keep_section:
-                result.extend(current_section)
-            return ([line], False)
-        return None
-
-    def _should_stop_extraction(self, result: list[str], target_size: int) -> bool:
-        return len("\n".join(result)) > target_size
-
-    def _finalize_extraction(
-        self,
-        current_section: list[str],
-        keep_section: bool,
-        result: list[str],
-        target_size: int,
-    ) -> None:
-        if current_section and keep_section and len("\n".join(result)) < target_size:
-            result.extend(current_section)
-
-    def _add_compression_notice(self, content: str) -> str:
-        notice = """
-*Note: This CLAUDE.md has been automatically compressed by Crackerjack to optimize for Claude Code usage.
-Complete documentation is available in the source repository.*
-
-"""
-
-        lines = content.split("\n")
-        if len(lines) > 5:
-            lines.insert(5, notice)
-
-        return "\n".join(lines)
-
-    def _customize_claude_md(self, content: str, compress: bool = False) -> str:
-        project_name = self.pkg_name
-        content = content.replace("crackerjack", project_name).replace(
-            "Crackerjack", project_name.title()
-        )
-        header = f"""# {project_name.upper()}.md
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-*This file was automatically generated by Crackerjack and contains the latest Python quality standards.*
-
-{project_name.title()} is a Python project that follows modern development practices and maintains high code quality standards using automated tools and best practices.
-
-"""
-
-        lines = content.split("\n")
-        start_idx = 0
-        for i, line in enumerate(lines):
-            if line.startswith(("## Development Guidelines", "## Code Quality")):
-                start_idx = i
-                break
-
-        if start_idx > 0:
-            relevant_content = "\n".join(lines[start_idx:])
-            full_content = header + relevant_content
-        else:
-            full_content = header + content
-
-        if compress:
-            return self._compress_claude_md(full_content)
-        return full_content
-
-    def _customize_rules_md(self, content: str) -> str:
-        project_name = self.pkg_name
-        content = content.replace("crackerjack", project_name).replace(
-            "Crackerjack", project_name.title()
-        )
-        header = f"""# {project_name.title()} Style Rules
-*This file was automatically generated by Crackerjack and contains the latest Python quality standards.*
-
-"""
-
-        return header + content
-
-    def execute_command(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]:
-        if self.dry_run:
-            self.console.print(
-                f"[bold bright_black]→ {' '.join(cmd)}[/bold bright_black]"
-            )
-            return CompletedProcess(cmd, 0, "", "")
-        return execute(cmd, **kwargs)
-
-
-class ProjectManager(BaseModel, arbitrary_types_allowed=True):
-    our_path: Path
-    pkg_path: Path
-    pkg_dir: Path | None = None
-    pkg_name: str = "crackerjack"
-    console: Console
-    code_cleaner: CodeCleaner
-    config_manager: ConfigManager
-    dry_run: bool = False
-    options: t.Any = None
-
-    def _analyze_precommit_workload(self) -> dict[str, t.Any]:
-        try:
-            py_files = list(self.pkg_path.rglob("*.py"))
-            js_files = list(self.pkg_path.rglob("*.js")) + list(
-                self.pkg_path.rglob("*.ts")
-            )
-            yaml_files = list(self.pkg_path.rglob("*.yaml")) + list(
-                self.pkg_path.rglob("*.yml")
-            )
-            md_files = list(self.pkg_path.rglob("*.md"))
-            total_files = (
-                len(py_files) + len(js_files) + len(yaml_files) + len(md_files)
-            )
-            total_size = 0
-            for files in (py_files, js_files, yaml_files, md_files):
-                for file_path in files:
-                    try:
-                        total_size += file_path.stat().st_size
-                    except (OSError, PermissionError):
-                        continue
-            if total_files > 200 or total_size > 5_000_000:
-                complexity = "high"
-            elif total_files > 100 or total_size > 2_000_000:
-                complexity = "medium"
-            else:
-                complexity = "low"
-
-            return {
-                "total_files": total_files,
-                "py_files": len(py_files),
-                "js_files": len(js_files),
-                "yaml_files": len(yaml_files),
-                "md_files": len(md_files),
-                "total_size": total_size,
-                "complexity": complexity,
-            }
-        except (OSError, PermissionError):
-            return {"complexity": "medium", "total_files": 0}
-
-    def _optimize_precommit_execution(
-        self, workload: dict[str, t.Any]
-    ) -> dict[str, t.Any]:
-        import os
-
-        env_vars = {}
-
-        if workload["complexity"] == "high":
-            env_vars["PRE_COMMIT_CONCURRENCY"] = str(min(os.cpu_count() or 4, 2))
-        elif workload["complexity"] == "medium":
-            env_vars["PRE_COMMIT_CONCURRENCY"] = str(min(os.cpu_count() or 4, 4))
-        else:
-            env_vars["PRE_COMMIT_CONCURRENCY"] = str(min(os.cpu_count() or 4, 6))
-
-        if workload["total_size"] > 10_000_000:
-            env_vars["PRE_COMMIT_MEMORY_LIMIT"] = "2G"
-
-        return env_vars
-
-    def update_pkg_configs(self) -> None:
-        self.config_manager.copy_configs()
-        installed_pkgs = self.execute_command(
-            ["uv", "pip", "list", "--freeze"], capture_output=True, text=True
-        ).stdout.splitlines()
-        if not len([pkg for pkg in installed_pkgs if "pre-commit" in pkg]):
-            self.console.print("\n" + "─" * 80)
-            self.console.print(
-                "[bold bright_blue]⚡ INIT[/bold bright_blue] [bold bright_white]First-time project setup[/bold bright_white]"
-            )
-            self.console.print("─" * 80 + "\n")
-            if self.options and getattr(self.options, "ai_agent", False):
-                import subprocess
-
-                self.execute_command(
-                    ["uv", "tool", "install", "keyring"],
-                    capture_output=True,
-                    stderr=subprocess.DEVNULL,
-                )
-            else:
-                self.execute_command(["uv", "tool", "install", "keyring"])
-            self.execute_command(["git", "init"])
-            self.execute_command(["git", "branch", "-m", "main"])
-            self.execute_command(["git", "add", "pyproject.toml", "uv.lock"])
-            self.execute_command(["git", "config", "advice.addIgnoredFile", "false"])
-            install_cmd = ["uv", "run", "pre-commit", "install"]
-            if self.options and getattr(self.options, "ai_agent", False):
-                install_cmd.extend(["-c", ".pre-commit-config-ai.yaml"])
-            else:
-                install_cmd.extend(["-c", ".pre-commit-config-fast.yaml"])
-            self.execute_command(install_cmd)
-            push_install_cmd = [
-                "uv",
-                "run",
-                "pre-commit",
-                "install",
-                "--hook-type",
-                "pre-push",
-            ]
-            self.execute_command(push_install_cmd)
-        self.config_manager.update_pyproject_configs()
-
-    def run_pre_commit(self) -> None:
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]🔍 HOOKS[/bold bright_cyan] [bold bright_white]Running code quality checks[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        workload = self._analyze_precommit_workload()
-        env_vars = self._optimize_precommit_execution(workload)
-        total_files = workload.get("total_files", 0)
-        if isinstance(total_files, int) and total_files > 50:
-            self.console.print(
-                f"[dim]Processing {total_files} files "
-                f"({workload.get('complexity', 'unknown')} complexity) with {env_vars.get('PRE_COMMIT_CONCURRENCY', 'auto')} workers[/dim]"
-            )
-        config_file = self._select_precommit_config()
-        cmd = ["uv", "run", "pre-commit", "run", "--all-files", "-c", config_file]
-        import os
-
-        env = os.environ.copy()
-        env.update(env_vars)
-        check_all = self.execute_command(cmd, env=env)
-        if check_all.returncode > 0:
-            self.execute_command(["uv", "lock"])
-            self.console.print("\n[bold green]✓ Dependencies locked[/bold green]\n")
-            check_all = self.execute_command(cmd, env=env)
-            if check_all.returncode > 0:
-                self.console.print(
-                    "\n\n[bold red]❌ Pre-commit failed. Please fix errors.[/bold red]\n"
-                )
-                raise SystemExit(1)
-
-    def _select_precommit_config(self) -> str:
-        if hasattr(self, "options"):
-            if getattr(self.options, "ai_agent", False):
-                return ".pre-commit-config-ai.yaml"
-            elif getattr(self.options, "comprehensive", False):
-                return ".pre-commit-config.yaml"
-
-        return ".pre-commit-config-fast.yaml"
-
-    def run_pre_commit_with_analysis(self) -> list[HookResult]:
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]🔍 HOOKS[/bold bright_cyan] [bold bright_white]Running code quality checks[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        config_file = self._select_precommit_config()
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "-c",
-            config_file,
-            "--verbose",
-        ]
-        start_time = time.time()
-        result = self.execute_command(cmd, capture_output=True, text=True)
-        total_duration = time.time() - start_time
-        hook_results = self._parse_hook_output(result.stdout, result.stderr)
-        if self.options and getattr(self.options, "ai_agent", False):
-            self._generate_hooks_analysis(hook_results, total_duration)
-            self._generate_quality_metrics()
-            self._generate_project_structure_analysis()
-            self._generate_error_context_analysis()
-            self._generate_ai_agent_summary()
-        if result.returncode > 0:
-            self.execute_command(["uv", "lock"])
-            self.console.print("\n[bold green]✓ Dependencies locked[/bold green]\n")
-            result = self.execute_command(cmd, capture_output=True, text=True)
-            if result.returncode > 0:
-                self.console.print(
-                    "\n\n[bold red]❌ Pre-commit failed. Please fix errors.[/bold red]\n"
-                )
-                raise SystemExit(1)
-
-        return hook_results
-
-    def _parse_hook_output(self, stdout: str, stderr: str) -> list[HookResult]:
-        hook_results: list[HookResult] = []
-        lines = stdout.split("\n")
-        for line in lines:
-            if "..." in line and (
-                "Passed" in line or "Failed" in line or "Skipped" in line
-            ):
-                hook_name = line.split("...")[0].strip()
-                status = (
-                    "passed"
-                    if "Passed" in line
-                    else "failed"
-                    if "Failed" in line
-                    else "skipped"
-                )
-                hook_results.append(
-                    HookResult(
-                        id=hook_name.lower().replace(" ", "-"),
-                        name=hook_name,
-                        status=status,
-                        duration=0.0,
-                        stage="pre-commit",
-                    )
-                )
-            elif "- duration:" in line and hook_results:
-                with suppress(ValueError, IndexError):
-                    duration = float(line.split("duration:")[1].strip().rstrip("s"))
-                    hook_results[-1].duration = duration
-
-        return hook_results
-
-    def _generate_hooks_analysis(
-        self, hook_results: list[HookResult], total_duration: float
-    ) -> None:
-        passed = sum(1 for h in hook_results if h.status == "passed")
-        failed = sum(1 for h in hook_results if h.status == "failed")
-
-        analysis = {
-            "summary": {
-                "total_hooks": len(hook_results),
-                "passed": passed,
-                "failed": failed,
-                "total_duration": round(total_duration, 2),
-                "status": "success" if failed == 0 else "failure",
-            },
-            "hooks": [
-                {
-                    "id": hook.id,
-                    "name": hook.name,
-                    "status": hook.status,
-                    "duration": hook.duration,
-                    "files_processed": hook.files_processed,
-                    "issues_found": hook.issues_found,
-                    "stage": hook.stage,
-                }
-                for hook in hook_results
-            ],
-            "performance": {
-                "slowest_hooks": sorted(
-                    [
-                        {
-                            "hook": h.name,
-                            "duration": h.duration,
-                            "percentage": round((h.duration / total_duration) * 100, 1),
-                        }
-                        for h in hook_results
-                        if h.duration > 0
-                    ],
-                    key=operator.itemgetter("duration"),
-                    reverse=True,
-                )[:5],
-                "optimization_suggestions": self._generate_optimization_suggestions(
-                    hook_results
-                ),
-            },
-            "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        }
-
-        with open("hooks-analysis.json", "w", encoding="utf-8") as f:
-            json.dump(analysis, f, indent=2)
-
-        self.console.print(
-            "[bold bright_black]→ Hook analysis: hooks-analysis.json[/bold bright_black]"
-        )
-
-    def _generate_optimization_suggestions(
-        self, hook_results: list[HookResult]
-    ) -> list[str]:
-        suggestions: list[str] = []
-
-        for hook in hook_results:
-            if hook.duration > 5.0:
-                suggestions.append(
-                    f"Consider moving {hook.name} to pre-push stage (currently {hook.duration}s)"
-                )
-            elif hook.name == "autotyping" and hook.duration > 3.0:
-                suggestions.append("Enable autotyping caching or reduce scope")
-
-        if not suggestions:
-            suggestions.append("Hook performance is well optimized")
-
-        return suggestions
-
-    def _generate_quality_metrics(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            return
-        metrics = {
-            "project_info": {
-                "name": self.pkg_name,
-                "python_version": "3.13+",
-                "crackerjack_version": "0.19.8",
-                "analysis_timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            },
-            "code_quality": self._collect_code_quality_metrics(),
-            "security": self._collect_security_metrics(),
-            "performance": self._collect_performance_metrics(),
-            "maintainability": self._collect_maintainability_metrics(),
-            "test_coverage": self._collect_coverage_metrics(),
-            "recommendations": self._generate_quality_recommendations(),
-        }
-        with open("quality-metrics.json", "w", encoding="utf-8") as f:
-            json.dump(metrics, f, indent=2)
-        self.console.print(
-            "[bold bright_black]→ Quality metrics: quality-metrics.json[/bold bright_black]"
-        )
-
-    def _collect_code_quality_metrics(self) -> dict[str, t.Any]:
-        return {
-            "ruff_check": self._parse_ruff_results(),
-            "pyright_types": self._parse_pyright_results(),
-            "refurb_patterns": self._parse_refurb_results(),
-            "complexity": self._parse_complexity_results(),
-        }
-
-    def _collect_security_metrics(self) -> dict[str, t.Any]:
-        return {
-            "bandit_issues": self._parse_bandit_results(),
-            "secrets_detected": self._parse_secrets_results(),
-            "dependency_vulnerabilities": self._check_dependency_security(),
-        }
-
-    def _collect_performance_metrics(self) -> dict[str, t.Any]:
-        return {
-            "import_analysis": self._analyze_imports(),
-            "dead_code": self._parse_vulture_results(),
-            "unused_dependencies": self._parse_creosote_results(),
-        }
-
-    def _collect_maintainability_metrics(self) -> dict[str, t.Any]:
-        return {
-            "line_count": self._count_code_lines(),
-            "file_count": self._count_files(),
-            "docstring_coverage": self._calculate_docstring_coverage(),
-            "type_annotation_coverage": self._calculate_type_coverage(),
-        }
-
-    def _collect_coverage_metrics(self) -> dict[str, t.Any]:
-        try:
-            with open("coverage.json", encoding="utf-8") as f:
-                coverage_data = json.load(f)
-                return {
-                    "total_coverage": coverage_data.get("totals", {}).get(
-                        "percent_covered", 0
-                    ),
-                    "missing_lines": coverage_data.get("totals", {}).get(
-                        "missing_lines", 0
-                    ),
-                    "covered_lines": coverage_data.get("totals", {}).get(
-                        "covered_lines", 0
-                    ),
-                    "files": len(coverage_data.get("files", {})),
-                }
-        except (FileNotFoundError, json.JSONDecodeError):
-            return {"status": "coverage_not_available"}
-
-    def _parse_ruff_results(self) -> dict[str, t.Any]:
-        return {"status": "clean", "violations": 0, "categories": []}
-
-    def _parse_pyright_results(self) -> dict[str, t.Any]:
-        return {"errors": 0, "warnings": 0, "type_coverage": "high"}
-
-    def _parse_refurb_results(self) -> dict[str, t.Any]:
-        return {"suggestions": 0, "patterns_modernized": []}
-
-    def _parse_complexity_list(
-        self, complexity_data: list[dict[str, t.Any]]
-    ) -> dict[str, t.Any]:
-        if not complexity_data:
-            return {
-                "average_complexity": 0,
-                "max_complexity": 0,
-                "total_functions": 0,
-            }
-        complexities = [item.get("complexity", 0) for item in complexity_data]
-        return {
-            "average_complexity": sum(complexities) / len(complexities)
-            if complexities
-            else 0,
-            "max_complexity": max(complexities) if complexities else 0,
-            "total_functions": len(complexities),
-        }
-
-    def _parse_complexity_dict(
-        self, complexity_data: dict[str, t.Any]
-    ) -> dict[str, t.Any]:
-        return {
-            "average_complexity": complexity_data.get("average", 0),
-            "max_complexity": complexity_data.get("max", 0),
-            "total_functions": complexity_data.get("total", 0),
-        }
-
-    def _parse_complexity_results(self) -> dict[str, t.Any]:
-        try:
-            with open("complexipy.json", encoding="utf-8") as f:
-                complexity_data = json.load(f)
-                if isinstance(complexity_data, list):
-                    return self._parse_complexity_list(
-                        t.cast(list[dict[str, t.Any]], complexity_data)
-                    )
-                return self._parse_complexity_dict(complexity_data)
-        except (FileNotFoundError, json.JSONDecodeError):
-            return {"status": "complexity_analysis_not_available"}
-
-    def _parse_bandit_results(self) -> dict[str, t.Any]:
-        return {"high_severity": 0, "medium_severity": 0, "low_severity": 0}
-
-    def _parse_secrets_results(self) -> dict[str, t.Any]:
-        return {"potential_secrets": 0, "verified_secrets": 0}
-
-    def _check_dependency_security(self) -> dict[str, t.Any]:
-        return {"vulnerable_packages": [], "total_dependencies": 0}
-
-    def _analyze_imports(self) -> dict[str, t.Any]:
-        return {"circular_imports": 0, "unused_imports": 0, "import_depth": "shallow"}
-
-    def _parse_vulture_results(self) -> dict[str, t.Any]:
-        return {"dead_code_percentage": 0, "unused_functions": 0, "unused_variables": 0}
-
-    def _parse_creosote_results(self) -> dict[str, t.Any]:
-        return {"unused_dependencies": [], "total_dependencies": 0}
-
-    def _count_code_lines(self) -> int:
-        total_lines = 0
-        for py_file in self.pkg_path.rglob("*.py"):
-            if not str(py_file).startswith(("__pycache__", ".venv")):
-                try:
-                    total_lines += len(py_file.read_text(encoding="utf-8").splitlines())
-                except (UnicodeDecodeError, PermissionError):
-                    continue
-        return total_lines
-
-    def _count_files(self) -> dict[str, int]:
-        return {
-            "python_files": len(list(self.pkg_path.rglob("*.py"))),
-            "test_files": len(list(self.pkg_path.rglob("test_*.py"))),
-            "config_files": len(list(self.pkg_path.glob("*.toml")))
-            + len(list(self.pkg_path.glob("*.yaml"))),
-        }
-
-    def _calculate_docstring_coverage(self) -> float:
-        return 85.0
-
-    def _calculate_type_coverage(self) -> float:
-        return 95.0
-
-    def _generate_quality_recommendations(self) -> list[str]:
-        recommendations: list[str] = []
-        recommendations.extend(
-            [
-                "Consider adding more integration tests",
-                "Review complex functions for potential refactoring",
-                "Ensure all public APIs have comprehensive docstrings",
-                "Monitor dependency updates for security patches",
-            ]
-        )
-
-        return recommendations
-
-    def _generate_project_structure_analysis(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            return
-        structure = {
-            "project_overview": {
-                "name": self.pkg_name,
-                "type": "python_package",
-                "structure_pattern": self._analyze_project_pattern(),
-                "analysis_timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            },
-            "directory_structure": self._analyze_directory_structure(),
-            "file_distribution": self._analyze_file_distribution(),
-            "dependencies": self._analyze_dependencies(),
-            "configuration_files": self._analyze_configuration_files(),
-            "documentation": self._analyze_documentation(),
-            "testing_structure": self._analyze_testing_structure(),
-            "package_structure": self._analyze_package_structure(),
-        }
-        with open("project-structure.json", "w", encoding="utf-8") as f:
-            json.dump(structure, f, indent=2)
-        self.console.print(
-            "[bold bright_black]→ Project structure: project-structure.json[/bold bright_black]"
-        )
-
-    def _generate_error_context_analysis(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            return
-        context = {
-            "analysis_info": {
-                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                "crackerjack_version": "0.19.8",
-                "python_version": "3.13+",
-            },
-            "environment": self._collect_environment_info(),
-            "common_issues": self._identify_common_issues(),
-            "troubleshooting": self._generate_troubleshooting_guide(),
-            "performance_insights": self._collect_performance_insights(),
-            "recommendations": self._generate_context_recommendations(),
-        }
-        with open("error-context.json", "w", encoding="utf-8") as f:
-            json.dump(context, f, indent=2)
-        self.console.print(
-            "[bold bright_black]→ Error context: error-context.json[/bold bright_black]"
-        )
-
-    def _generate_ai_agent_summary(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            return
-        summary = {
-            "analysis_summary": {
-                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                "project_name": self.pkg_name,
-                "analysis_type": "comprehensive_quality_assessment",
-                "crackerjack_version": "0.19.8",
-            },
-            "quality_status": self._summarize_quality_status(),
-            "key_metrics": self._summarize_key_metrics(),
-            "critical_issues": self._identify_critical_issues(),
-            "improvement_priorities": self._prioritize_improvements(),
-            "next_steps": self._recommend_next_steps(),
-            "output_files": [
-                "hooks-analysis.json",
-                "quality-metrics.json",
-                "project-structure.json",
-                "error-context.json",
-                "test-results.xml",
-                "coverage.json",
-            ],
-        }
-        with open("ai-agent-summary.json", "w", encoding="utf-8") as f:
-            json.dump(summary, f, indent=2)
-        self.console.print(
-            "[bold bright_black]→ AI agent summary: ai-agent-summary.json[/bold bright_black]"
-        )
-
-    def _analyze_project_pattern(self) -> str:
-        if (self.pkg_path / "pyproject.toml").exists():
-            if (self.pkg_path / "src").exists():
-                return "src_layout"
-            elif (self.pkg_path / self.pkg_name).exists():
-                return "flat_layout"
-        return "unknown"
-
-    def _analyze_directory_structure(self) -> dict[str, t.Any]:
-        directories = [
-            {
-                "name": item.name,
-                "type": self._classify_directory(item),
-                "file_count": len(list(item.rglob("*"))),
-            }
-            for item in self.pkg_path.iterdir()
-            if item.is_dir()
-            and not item.name.startswith((".git", "__pycache__", ".venv"))
-        ]
-        return {"directories": directories, "total_directories": len(directories)}
-
-    def _analyze_file_distribution(self) -> dict[str, t.Any]:
-        file_types: dict[str, int] = {}
-        total_files = 0
-        for file_path in self.pkg_path.rglob("*"):
-            if file_path.is_file() and not str(file_path).startswith(
-                (".git", "__pycache__")
-            ):
-                ext = file_path.suffix or "no_extension"
-                file_types[ext] = file_types.get(ext, 0) + 1
-                total_files += 1
-
-        return {"file_types": file_types, "total_files": total_files}
-
-    def _analyze_dependencies(self) -> dict[str, t.Any]:
-        deps = {"status": "analysis_not_implemented"}
-        with suppress(Exception):
-            pyproject_path = self.pkg_path / "pyproject.toml"
-            if pyproject_path.exists():
-                pyproject_path.read_text(encoding="utf-8")
-                deps = {"source": "pyproject.toml", "status": "detected"}
-        return deps
-
-    def _analyze_configuration_files(self) -> list[str]:
-        config_files: list[str] = []
-        config_patterns = ["*.toml", "*.yaml", "*.yml", "*.ini", "*.cfg", ".env*"]
-        for pattern in config_patterns:
-            config_files.extend([f.name for f in self.pkg_path.glob(pattern)])
-
-        return sorted(set(config_files))
-
-    def _analyze_documentation(self) -> dict[str, t.Any]:
-        docs = {"readme": False, "docs_dir": False, "changelog": False}
-        for file_path in self.pkg_path.iterdir():
-            if file_path.is_file():
-                name_lower = file_path.name.lower()
-                if name_lower.startswith("readme"):
-                    docs["readme"] = True
-                elif name_lower.startswith(("changelog", "history")):
-                    docs["changelog"] = True
-            elif file_path.is_dir() and file_path.name.lower() in (
-                "docs",
-                "doc",
-                "documentation",
-            ):
-                docs["docs_dir"] = True
-
-        return docs
-
-    def _analyze_testing_structure(self) -> dict[str, t.Any]:
-        test_files = list(self.pkg_path.rglob("test_*.py"))
-        test_dirs = [
-            d
-            for d in self.pkg_path.iterdir()
-            if d.is_dir() and "test" in d.name.lower()
-        ]
-
-        return {
-            "test_files": len(test_files),
-            "test_directories": len(test_dirs),
-            "has_conftest": any(
-                f.name == "conftest.py" for f in self.pkg_path.rglob("conftest.py")
-            ),
-            "has_pytest_ini": (self.pkg_path / "pytest.ini").exists(),
-        }
-
-    def _analyze_package_structure(self) -> dict[str, t.Any]:
-        pkg_dir = self.pkg_path / self.pkg_name
-        if not pkg_dir.exists():
-            return {"status": "no_package_directory"}
-        py_files = list(pkg_dir.rglob("*.py"))
-        return {
-            "python_files": len(py_files),
-            "has_init": (pkg_dir / "__init__.py").exists(),
-            "submodules": len(
-                [
-                    f
-                    for f in pkg_dir.iterdir()
-                    if f.is_dir() and (f / "__init__.py").exists()
-                ]
-            ),
-        }
-
-    def _classify_directory(self, directory: Path) -> str:
-        name = directory.name.lower()
-        if name in ("test", "tests"):
-            return "testing"
-        elif name in ("doc", "docs", "documentation"):
-            return "documentation"
-        elif name in ("src", "lib"):
-            return "source"
-        elif name.startswith("."):
-            return "hidden"
-        elif (directory / "__init__.py").exists():
-            return "python_package"
-        return "general"
-
-    def _collect_environment_info(self) -> dict[str, t.Any]:
-        return {
-            "platform": "detected_automatically",
-            "python_version": "3.13+",
-            "virtual_env": "detected_automatically",
-            "git_status": "available",
-        }
-
-    def _identify_common_issues(self) -> list[str]:
-        issues: list[str] = []
-        if not (self.pkg_path / "pyproject.toml").exists():
-            issues.append("Missing pyproject.toml configuration")
-        if not (self.pkg_path / ".gitignore").exists():
-            issues.append("Missing .gitignore file")
-
-        return issues
-
-    def _generate_troubleshooting_guide(self) -> dict[str, str]:
-        return {
-            "dependency_issues": "Run 'uv sync' to ensure all dependencies are installed",
-            "hook_failures": "Check hook-specific configuration in pyproject.toml",
-            "type_errors": "Review type annotations and ensure pyright configuration is correct",
-            "formatting_issues": "Run 'uv run ruff format' to fix formatting automatically",
-        }
-
-    def _collect_performance_insights(self) -> dict[str, t.Any]:
-        return {
-            "hook_performance": "Available in hooks-analysis.json",
-            "test_performance": "Available in test output",
-            "optimization_opportunities": "Check quality-metrics.json for details",
-        }
-
-    def _generate_context_recommendations(self) -> list[str]:
-        return [
-            "Regular pre-commit hook execution to maintain code quality",
-            "Periodic dependency updates for security and performance",
-            "Monitor test coverage and add tests for uncovered code",
-            "Review and update type annotations for better code safety",
-        ]
-
-    def _summarize_quality_status(self) -> str:
-        return "analysis_complete"
-
-    def _summarize_key_metrics(self) -> dict[str, t.Any]:
-        return {
-            "code_quality": "high",
-            "test_coverage": "good",
-            "security_status": "clean",
-            "maintainability": "excellent",
-        }
-
-    def _identify_critical_issues(self) -> list[str]:
-        return []
-
-    def _prioritize_improvements(self) -> list[str]:
-        return [
-            "Continue maintaining high code quality standards",
-            "Monitor performance metrics regularly",
-            "Keep dependencies up to date",
-        ]
-
-    def _recommend_next_steps(self) -> list[str]:
-        return [
-            "Review generated analysis files for detailed insights",
-            "Address any identified issues or recommendations",
-            "Set up regular automated quality checks",
-            "Consider integrating analysis into CI/CD pipeline",
-        ]
-
-    def execute_command(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]:
-        if self.dry_run:
-            self.console.print(
-                f"[bold bright_black]→ {' '.join(cmd)}[/bold bright_black]"
-            )
-            return CompletedProcess(cmd, 0, "", "")
-        return execute(cmd, **kwargs)
-
-    async def execute_command_async(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]:
-        if self.dry_run:
-            self.console.print(
-                f"[bold bright_black]→ {' '.join(cmd)}[/bold bright_black]"
-            )
-            return CompletedProcess(cmd, 0, "", "")
-
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            **kwargs,
-        )
-        stdout, stderr = await proc.communicate()
-
-        return CompletedProcess(
-            cmd,
-            proc.returncode or 0,
-            stdout.decode() if stdout else "",
-            stderr.decode() if stderr else "",
-        )
-
-    async def run_pre_commit_async(self) -> None:
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]🔍 HOOKS[/bold bright_cyan] [bold bright_white]Running code quality checks[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        workload = self._analyze_precommit_workload()
-        env_vars = self._optimize_precommit_execution(workload)
-        total_files = workload.get("total_files", 0)
-        if isinstance(total_files, int) and total_files > 50:
-            self.console.print(
-                f"[dim]Processing {total_files} files "
-                f"({workload.get('complexity', 'unknown')} complexity) with {env_vars.get('PRE_COMMIT_CONCURRENCY', 'auto')} workers[/dim]"
-            )
-        config_file = self._select_precommit_config()
-        cmd = ["uv", "run", "pre-commit", "run", "--all-files", "-c", config_file]
-        import os
-
-        env = os.environ.copy()
-        env.update(env_vars)
-        check_all = await self.execute_command_async(cmd, env=env)
-        if check_all.returncode > 0:
-            await self.execute_command_async(["uv", "lock"])
-            self.console.print(
-                "\n[bold bright_red]❌ Pre-commit failed. Please fix errors.[/bold bright_red]"
-            )
-            if check_all.stderr:
-                self.console.print(f"[dim]Error details: {check_all.stderr}[/dim]")
-            raise SystemExit(1)
-        else:
-            self.console.print(
-                "\n[bold bright_green]🏆 Pre-commit passed all checks![/bold bright_green]"
-            )
-
-    async def run_pre_commit_with_analysis_async(self) -> list[HookResult]:
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]🔍 HOOKS[/bold bright_cyan] [bold bright_white]Running code quality checks[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        config_file = self._select_precommit_config()
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "-c",
-            config_file,
-            "--verbose",
-        ]
-        self.console.print(
-            f"[dim]→ Analysis files: {', '.join(self._get_analysis_files())}[/dim]"
-        )
-        start_time = time.time()
-        check_all = await self.execute_command_async(cmd)
-        end_time = time.time()
-        hook_results = [
-            HookResult(
-                id="async_pre_commit",
-                name="Pre-commit hooks (async)",
-                status="passed" if check_all.returncode == 0 else "failed",
-                duration=round(end_time - start_time, 2),
-                files_processed=0,
-                issues_found=[],
-            )
-        ]
-        if check_all.returncode > 0:
-            await self.execute_command_async(["uv", "lock"])
-            self.console.print(
-                "\n[bold bright_red]❌ Pre-commit failed. Please fix errors.[/bold bright_red]"
-            )
-            if check_all.stderr:
-                self.console.print(f"[dim]Error details: {check_all.stderr}[/dim]")
-            raise SystemExit(1)
-        else:
-            self.console.print(
-                "\n[bold bright_green]🏆 Pre-commit passed all checks![/bold bright_green]"
-            )
-        self._generate_analysis_files(hook_results)
-
-        return hook_results
-
-    def _get_analysis_files(self) -> list[str]:
-        analysis_files: list[str] = []
-        if (
-            hasattr(self, "options")
-            and self.options
-            and getattr(self.options, "ai_agent", False)
-        ):
-            analysis_files.extend(
-                [
-                    "test-results.xml",
-                    "coverage.json",
-                    "benchmark.json",
-                    "ai-agent-summary.json",
-                ]
-            )
-        return analysis_files
-
-    def _generate_analysis_files(self, hook_results: list[HookResult]) -> None:
-        if not (
-            hasattr(self, "options")
-            and self.options
-            and getattr(self.options, "ai_agent", False)
-        ):
-            return
-        try:
-            import json
-
-            summary = {
-                "status": "success"
-                if all(hr.status == "Passed" for hr in hook_results)
-                else "failed",
-                "hook_results": [
-                    {
-                        "name": hr.name,
-                        "status": hr.status,
-                        "duration": hr.duration,
-                        "issues": hr.issues_found
-                        if hasattr(hr, "issues_found")
-                        else [],
-                    }
-                    for hr in hook_results
-                ],
-                "total_duration": sum(hr.duration for hr in hook_results),
-                "files_analyzed": len(hook_results),
-            }
-            with open("ai-agent-summary.json", "w") as f:
-                json.dump(summary, f, indent=2)
-        except Exception as e:
-            self.console.print(
-                f"[yellow]Warning: Failed to generate AI summary: {e}[/yellow]"
-            )
-
-    def update_precommit_hooks(self) -> None:
-        try:
-            result = self.execute_command(
-                ["uv", "run", "pre-commit", "autoupdate"],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                self.console.print(
-                    "[green]✅ Pre-commit hooks updated successfully[/green]"
-                )
-                if result.stdout.strip():
-                    self.console.print(f"[dim]{result.stdout}[/dim]")
-            else:
-                self.console.print(
-                    f"[red]❌ Failed to update pre-commit hooks: {result.stderr}[/red]"
-                )
-        except Exception as e:
-            self.console.print(f"[red]❌ Error updating pre-commit hooks: {e}[/red]")
-
-
-class Crackerjack(BaseModel, arbitrary_types_allowed=True):
-    our_path: Path = Path(__file__).parent
-    pkg_path: Path = Path(Path.cwd())
-    pkg_dir: Path | None = None
-    pkg_name: str = "crackerjack"
-    python_version: str = default_python_version
-    console: Console = Console(force_terminal=True)
-    dry_run: bool = False
-    code_cleaner: CodeCleaner | None = None
-    config_manager: ConfigManager | None = None
-    project_manager: ProjectManager | None = None
-    session_tracker: SessionTracker | None = None
-    options: t.Any = None
-    _file_cache: dict[str, list[Path]] = {}
-    _file_cache_with_mtime: dict[str, tuple[float, list[Path]]] = {}
-    _state_file: Path = Path(".crackerjack-state")
-
-    def __init__(self, **data: t.Any) -> None:
-        super().__init__(**data)
-        self._file_cache = {}
-        self._file_cache_with_mtime = {}
-        self._state_file = Path(".crackerjack-state")
-        self.code_cleaner = CodeCleaner(console=self.console)
-        self.config_manager = ConfigManager(
-            our_path=self.our_path,
-            pkg_path=self.pkg_path,
-            pkg_name=self.pkg_name,
-            console=self.console,
-            python_version=self.python_version,
-            dry_run=self.dry_run,
-        )
-        self.project_manager = ProjectManager(
-            our_path=self.our_path,
-            pkg_path=self.pkg_path,
-            pkg_dir=self.pkg_dir,
-            pkg_name=self.pkg_name,
-            console=self.console,
-            code_cleaner=self.code_cleaner,
-            config_manager=self.config_manager,
-            dry_run=self.dry_run,
-        )
-
-    def _read_state(self) -> dict[str, t.Any]:
-        import json
-
-        if self._state_file.exists():
-            try:
-                return json.loads(self._state_file.read_text(encoding="utf-8"))
-            except (json.JSONDecodeError, OSError):
-                return {}
-        return {}
-
-    def _write_state(self, state: dict[str, t.Any]) -> None:
-        from contextlib import suppress
-
-        with suppress(OSError):
-            import json
-
-            self._state_file.write_text(json.dumps(state, indent=2), encoding="utf-8")
-
-    def _clear_state(self) -> None:
-        if self._state_file.exists():
-            from contextlib import suppress
-
-            with suppress(OSError):
-                self._state_file.unlink()
-
-    def _has_version_been_bumped(self, version_type: str) -> bool:
-        state = self._read_state()
-        current_version = self._get_current_version()
-        last_bumped_version = state.get("last_bumped_version")
-        last_bump_type = state.get("last_bump_type")
-
-        return (
-            last_bumped_version == current_version
-            and last_bump_type == version_type
-            and not state.get("publish_completed", False)
-        )
-
-    def _mark_version_bumped(self, version_type: str) -> None:
-        current_version = self._get_current_version()
-        state = self._read_state()
-        state.update(
-            {
-                "last_bumped_version": current_version,
-                "last_bump_type": version_type,
-                "publish_completed": False,
-            }
-        )
-        self._write_state(state)
-
-    def _mark_publish_completed(self) -> None:
-        state = self._read_state()
-        state["publish_completed"] = True
-        self._write_state(state)
-
-    def _get_current_version(self) -> str:
-        from contextlib import suppress
-
-        with suppress(Exception):
-            import tomllib
-
-            pyproject_path = Path("pyproject.toml")
-            if pyproject_path.exists():
-                with pyproject_path.open("rb") as f:
-                    data = tomllib.load(f)
-                    return data.get("project", {}).get("version", "unknown")
-        return "unknown"
-
-    def _setup_package(self) -> None:
-        self.pkg_name = self.pkg_path.stem.lower().replace("-", "_")
-        self.pkg_dir = self.pkg_path / self.pkg_name
-        self.pkg_dir.mkdir(exist_ok=True)
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_magenta]🛠️  SETUP[/bold bright_magenta] [bold bright_white]Initializing project structure[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        assert self.config_manager is not None
-        assert self.project_manager is not None
-        self.config_manager.pkg_name = self.pkg_name
-        self.project_manager.pkg_name = self.pkg_name
-        self.project_manager.pkg_dir = self.pkg_dir
-
-    def _update_project(self, options: t.Any) -> None:
-        assert self.project_manager is not None
-        if not options.no_config_updates:
-            self.project_manager.update_pkg_configs()
-            result: CompletedProcess[str] = self.execute_command(
-                ["uv", "sync"], capture_output=True, text=True
-            )
-            if result.returncode == 0:
-                self.console.print(
-                    "[bold green]✓ Dependencies installed[/bold green]\n"
-                )
-            else:
-                self.console.print(
-                    "\n\n[bold red]❌ UV sync failed. Is UV installed? Run `pipx install uv` and try again.[/bold red]\n\n"
-                )
-
-    def _clean_project(self, options: t.Any) -> None:
-        assert self.code_cleaner is not None
-        if options.clean:
-            if self.pkg_dir:
-                self.console.print("\n" + "-" * 80)
-                self.console.print(
-                    "[bold bright_blue]🧹 CLEAN[/bold bright_blue] [bold bright_white]Removing docstrings and comments[/bold bright_white]"
-                )
-                self.console.print("-" * 80 + "\n")
-                self.code_cleaner.clean_files(self.pkg_dir)
-            if self.pkg_path.stem == "crackerjack":
-                tests_dir = self.pkg_path / "tests"
-                if tests_dir.exists() and tests_dir.is_dir():
-                    self.console.print("\n" + "─" * 80)
-                    self.console.print(
-                        "[bold bright_blue]🧪 TESTS[/bold bright_blue] [bold bright_white]Cleaning test files[/bold bright_white]"
-                    )
-                    self.console.print("─" * 80 + "\n")
-                    self.code_cleaner.clean_files(tests_dir)
-
-    async def _clean_project_async(self, options: t.Any) -> None:
-        assert self.code_cleaner is not None
-        if options.clean:
-            if self.pkg_dir:
-                self.console.print("\n" + "-" * 80)
-                self.console.print(
-                    "[bold bright_blue]🧹 CLEAN[/bold bright_blue] [bold bright_white]Removing docstrings and comments[/bold bright_white]"
-                )
-                self.console.print("-" * 80 + "\n")
-                await self.code_cleaner.clean_files_async(self.pkg_dir)
-            if self.pkg_path.stem == "crackerjack":
-                tests_dir = self.pkg_path / "tests"
-                if tests_dir.exists() and tests_dir.is_dir():
-                    self.console.print("\n" + "─" * 80)
-                    self.console.print(
-                        "[bold bright_blue]🧪 TESTS[/bold bright_blue] [bold bright_white]Cleaning test files[/bold bright_white]"
-                    )
-                    self.console.print("─" * 80 + "\n")
-                    await self.code_cleaner.clean_files_async(tests_dir)
-
-    def _get_test_timeout(self, options: OptionsProtocol, project_size: str) -> int:
-        if options.test_timeout > 0:
-            return options.test_timeout
-        return (
-            360 if project_size == "large" else 240 if project_size == "medium" else 120
-        )
-
-    def _add_ai_agent_flags(
-        self, test: list[str], options: OptionsProtocol, test_timeout: int
-    ) -> None:
-        test.extend(
-            [
-                "--junitxml=test-results.xml",
-                "--cov-report=json:coverage.json",
-                "--tb=short",
-                "--no-header",
-                "--quiet",
-                f"--timeout={test_timeout}",
-            ]
-        )
-        if options.benchmark or options.benchmark_regression:
-            test.append("--benchmark-json=benchmark.json")
-
-    def _add_standard_flags(self, test: list[str], test_timeout: int) -> None:
-        test.extend(
-            [
-                "--capture=fd",
-                "--tb=short",
-                "--no-header",
-                "--disable-warnings",
-                "--durations=0",
-                f"--timeout={test_timeout}",
-            ]
-        )
-
-    def _add_benchmark_flags(self, test: list[str], options: OptionsProtocol) -> None:
-        if options.benchmark:
-            test.extend(["--benchmark", "--benchmark-autosave"])
-        if options.benchmark_regression:
-            test.extend(
-                [
-                    "--benchmark-regression",
-                    f"--benchmark-regression-threshold={options.benchmark_regression_threshold}",
-                ]
-            )
-
-    def _add_worker_flags(
-        self, test: list[str], options: OptionsProtocol, project_size: str
-    ) -> None:
-        if options.test_workers > 0:
-            if options.test_workers == 1:
-                test.append("-vs")
-            else:
-                test.extend(["-xvs", "-n", str(options.test_workers)])
-        else:
-            workload = self._analyze_test_workload()
-            optimal_workers = self._calculate_optimal_test_workers(workload)
-
-            if workload.get("test_files", 0) < 5:
-                test.append("-xvs")
-            else:
-                test_files = workload.get("test_files", 0)
-                if isinstance(test_files, int) and test_files > 20:
-                    self.console.print(
-                        f"[dim]Running {test_files} tests "
-                        f"({workload.get('complexity', 'unknown')} complexity) with {optimal_workers} workers[/dim]"
-                    )
-
-                if optimal_workers == 1:
-                    test.append("-vs")
-                else:
-                    test.extend(["-xvs", "-n", str(optimal_workers)])
-
-    def _prepare_pytest_command(self, options: OptionsProtocol) -> list[str]:
-        test = ["uv", "run", "pytest"]
-        project_size = self._detect_project_size()
-        test_timeout = self._get_test_timeout(options, project_size)
-        if getattr(options, "ai_agent", False):
-            self._add_ai_agent_flags(test, options, test_timeout)
-        else:
-            self._add_standard_flags(test, test_timeout)
-        if options.benchmark or options.benchmark_regression:
-            self._add_benchmark_flags(test, options)
-        else:
-            self._add_worker_flags(test, options, project_size)
-        return test
-
-    def _get_cached_files(self, pattern: str) -> list[Path]:
-        cache_key = f"{self.pkg_path}:{pattern}"
-        if cache_key not in self._file_cache:
-            try:
-                self._file_cache[cache_key] = list(self.pkg_path.rglob(pattern))
-            except (OSError, PermissionError):
-                self._file_cache[cache_key] = []
-        return self._file_cache[cache_key]
-
-    def _get_cached_files_with_mtime(self, pattern: str) -> list[Path]:
-        cache_key = f"{self.pkg_path}:{pattern}"
-        current_mtime = self._get_directory_mtime(self.pkg_path)
-        if cache_key in self._file_cache_with_mtime:
-            cached_mtime, cached_files = self._file_cache_with_mtime[cache_key]
-            if cached_mtime >= current_mtime:
-                return cached_files
-        try:
-            files = list(self.pkg_path.rglob(pattern))
-            self._file_cache_with_mtime[cache_key] = (current_mtime, files)
-            return files
-        except (OSError, PermissionError):
-            self._file_cache_with_mtime[cache_key] = (current_mtime, [])
-            return []
-
-    def _get_directory_mtime(self, path: Path) -> float:
-        try:
-            max_mtime = path.stat().st_mtime
-            for item in path.iterdir():
-                if item.is_dir() and not item.name.startswith("."):
-                    try:
-                        dir_mtime = item.stat().st_mtime
-                        max_mtime = max(max_mtime, dir_mtime)
-                    except (OSError, PermissionError):
-                        continue
-                elif item.is_file() and item.suffix == ".py":
-                    try:
-                        file_mtime = item.stat().st_mtime
-                        max_mtime = max(max_mtime, file_mtime)
-                    except (OSError, PermissionError):
-                        continue
-
-            return max_mtime
-        except (OSError, PermissionError):
-            return 0.0
-
-    def _detect_project_size(self) -> str:
-        if self.pkg_name in ("acb", "fastblocks"):
-            return "large"
-        try:
-            py_files = self._get_cached_files_with_mtime("*.py")
-            test_files = self._get_cached_files_with_mtime("test_*.py")
-            total_files = len(py_files)
-            num_test_files = len(test_files)
-            if total_files > 100 or num_test_files > 50:
-                return "large"
-            elif total_files > 50 or num_test_files > 20:
-                return "medium"
-            else:
-                return "small"
-        except (OSError, PermissionError):
-            return "medium"
-
-    def _calculate_test_metrics(self, test_files: list[Path]) -> tuple[int, int]:
-        total_test_size = 0
-        slow_tests = 0
-        for test_file in test_files:
-            try:
-                size = test_file.stat().st_size
-                total_test_size += size
-                if size > 30_000 or "integration" in test_file.name.lower():
-                    slow_tests += 1
-            except (OSError, PermissionError):
-                continue
-        return total_test_size, slow_tests
-
-    def _determine_test_complexity(
-        self, test_count: int, avg_size: float, slow_ratio: float
-    ) -> str:
-        if test_count > 100 or avg_size > 25_000 or slow_ratio > 0.4:
-            return "high"
-        elif test_count > 50 or avg_size > 15_000 or slow_ratio > 0.2:
-            return "medium"
-        return "low"
-
-    def _analyze_test_workload(self) -> dict[str, t.Any]:
-        try:
-            test_files = self._get_cached_files_with_mtime("test_*.py")
-            py_files = self._get_cached_files_with_mtime("*.py")
-            total_test_size, slow_tests = self._calculate_test_metrics(test_files)
-            avg_test_size = total_test_size / len(test_files) if test_files else 0
-            slow_test_ratio = slow_tests / len(test_files) if test_files else 0
-            complexity = self._determine_test_complexity(
-                len(test_files), avg_test_size, slow_test_ratio
-            )
-            return {
-                "total_files": len(py_files),
-                "test_files": len(test_files),
-                "total_test_size": total_test_size,
-                "avg_test_size": avg_test_size,
-                "slow_tests": slow_tests,
-                "slow_test_ratio": slow_test_ratio,
-                "complexity": complexity,
-            }
-        except (OSError, PermissionError):
-            return {"complexity": "medium", "total_files": 0, "test_files": 0}
-
-    def _calculate_optimal_test_workers(self, workload: dict[str, t.Any]) -> int:
-        import os
-
-        cpu_count = os.cpu_count() or 4
-        if workload["complexity"] == "high":
-            return min(cpu_count // 3, 2)
-        elif workload["complexity"] == "medium":
-            return min(cpu_count // 2, 4)
-        return min(cpu_count, 8)
-
-    def _print_ai_agent_files(self, options: t.Any) -> None:
-        if getattr(options, "ai_agent", False):
-            self.console.print(
-                "[bold bright_black]→ Structured test results: test-results.xml[/bold bright_black]"
-            )
-            self.console.print(
-                "[bold bright_black]→ Coverage report: coverage.json[/bold bright_black]"
-            )
-            if options.benchmark or options.benchmark_regression:
-                self.console.print(
-                    "[bold bright_black]→ Benchmark results: benchmark.json[/bold bright_black]"
-                )
-
-    def _handle_test_failure(self, result: t.Any, options: t.Any) -> None:
-        if result.stderr:
-            self.console.print(result.stderr)
-        self.console.print(
-            "\n\n[bold bright_red]❌ Tests failed. Please fix errors.[/bold bright_red]\n"
-        )
-        self._print_ai_agent_files(options)
-        raise SystemExit(1)
-
-    def _handle_test_success(self, options: t.Any) -> None:
-        self.console.print(
-            "\n\n[bold bright_green]🏆 Tests passed successfully![/bold bright_green]\n"
-        )
-        self._print_ai_agent_files(options)
-
-    def _run_tests(self, options: t.Any) -> None:
-        if not options.test:
-            return
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_green]🧪 TESTING[/bold bright_green] [bold bright_white]Executing test suite[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        test_command = self._prepare_pytest_command(options)
-        result = self.execute_command(test_command, capture_output=True, text=True)
-        if result.stdout:
-            self.console.print(result.stdout)
-        if result.returncode > 0:
-            self._handle_test_failure(result, options)
-        else:
-            self._handle_test_success(options)
-
-    async def _run_tests_async(self, options: t.Any) -> None:
-        if not options.test:
-            return
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_green]🧪 TESTING[/bold bright_green] [bold bright_white]Executing test suite (async optimized)[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        test_command = self._prepare_pytest_command(options)
-        result = await self.execute_command_async(test_command)
-        if result.stdout:
-            self.console.print(result.stdout)
-        if result.returncode > 0:
-            self._handle_test_failure(result, options)
-        else:
-            self._handle_test_success(options)
-
-    def _bump_version(self, options: OptionsProtocol) -> None:
-        for option in (options.publish, options.bump):
-            if option:
-                version_type = str(option)
-                if self._has_version_been_bumped(version_type):
-                    self.console.print("\n" + "-" * 80)
-                    self.console.print(
-                        f"[bold yellow]📦 VERSION[/bold yellow] [bold bright_white]Version already bumped ({version_type}), skipping to avoid duplicate bump[/bold bright_white]"
-                    )
-                    self.console.print("-" * 80 + "\n")
-                    return
-                self.console.print("\n" + "-" * 80)
-                self.console.print(
-                    f"[bold bright_magenta]📦 VERSION[/bold bright_magenta] [bold bright_white]Bumping {option} version[/bold bright_white]"
-                )
-                self.console.print("-" * 80 + "\n")
-                if version_type in ("minor", "major"):
-                    from rich.prompt import Confirm
-
-                    if not Confirm.ask(
-                        f"Are you sure you want to bump the {option} version?",
-                        default=False,
-                    ):
-                        self.console.print(
-                            f"[bold yellow]⏭️  Skipping {option} version bump[/bold yellow]"
-                        )
-                        return
-                self.execute_command(["uv", "version", "--bump", option])
-                self._mark_version_bumped(version_type)
-                break
-
-    def _validate_authentication_setup(self) -> None:
-        import os
-        import shutil
-
-        keyring_provider = self._get_keyring_provider()
-        has_publish_token = bool(os.environ.get("UV_PUBLISH_TOKEN"))
-        has_keyring = shutil.which("keyring") is not None
-        self.console.print("[dim]🔐 Validating authentication setup...[/dim]")
-        if has_publish_token:
-            self._handle_publish_token_found()
-            return
-        if keyring_provider == "subprocess" and has_keyring:
-            self._handle_keyring_validation()
-            return
-        if keyring_provider == "subprocess" and not has_keyring:
-            self._handle_missing_keyring()
-        if not keyring_provider:
-            self._handle_no_keyring_provider()
-
-    def _handle_publish_token_found(self) -> None:
-        self.console.print(
-            "[dim]  ✅ UV_PUBLISH_TOKEN environment variable found[/dim]"
-        )
-
-    def _handle_keyring_validation(self) -> None:
-        self.console.print(
-            "[dim]  ✅ Keyring provider configured and keyring executable found[/dim]"
-        )
-        try:
-            result = self.execute_command(
-                ["keyring", "get", "https://upload.pypi.org/legacy/", "__token__"],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode == 0:
-                self.console.print("[dim]  ✅ PyPI token found in keyring[/dim]")
-            else:
-                self.console.print(
-                    "[yellow]  ⚠️  No PyPI token found in keyring - will prompt during publish[/yellow]"
-                )
-        except Exception:
-            self.console.print(
-                "[yellow]  ⚠️  Could not check keyring - will attempt publish anyway[/yellow]"
-            )
-
-    def _handle_missing_keyring(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            self.console.print(
-                "[yellow]  ⚠️  Keyring provider set to 'subprocess' but keyring executable not found[/yellow]"
-            )
-            self.console.print(
-                "[yellow]      Install keyring: uv tool install keyring[/yellow]"
-            )
-
-    def _handle_no_keyring_provider(self) -> None:
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            self.console.print(
-                "[yellow]  ⚠️  No keyring provider configured and no UV_PUBLISH_TOKEN set[/yellow]"
-            )
-
-    def _get_keyring_provider(self) -> str | None:
-        import os
-        import tomllib
-        from pathlib import Path
-
-        env_provider = os.environ.get("UV_KEYRING_PROVIDER")
-        if env_provider:
-            return env_provider
-        for config_file in ("pyproject.toml", "uv.toml"):
-            config_path = Path(config_file)
-            if config_path.exists():
-                try:
-                    with config_path.open("rb") as f:
-                        config = tomllib.load(f)
-                    return config.get("tool", {}).get("uv", {}).get("keyring-provider")
-                except Exception:
-                    continue
-
-        return None
-
-    def _build_publish_command(self) -> list[str]:
-        import os
-
-        cmd = ["uv", "publish"]
-        publish_token = os.environ.get("UV_PUBLISH_TOKEN")
-        if publish_token:
-            cmd.extend(["--token", publish_token])
-        keyring_provider = self._get_keyring_provider()
-        if keyring_provider:
-            cmd.extend(["--keyring-provider", keyring_provider])
-
-        return cmd
-
-    def _display_authentication_help(self) -> None:
-        self.console.print(
-            "\n[bold bright_red]❌ Publish failed. Run crackerjack again to retry publishing without re-bumping version.[/bold bright_red]"
-        )
-        if not (self.options and getattr(self.options, "ai_agent", False)):
-            self.console.print("\n[bold yellow]🔐 Authentication Help:[/bold yellow]")
-            self.console.print("  [dim]To fix authentication issues, you can:[/dim]")
-            self.console.print(
-                "  [dim]1. Set PyPI token: export UV_PUBLISH_TOKEN=pypi-your-token-here[/dim]"
-            )
-            self.console.print(
-                "  [dim]2. Install keyring: uv tool install keyring[/dim]"
-            )
-            self.console.print(
-                "  [dim]3. Store token in keyring: keyring set https://upload.pypi.org/legacy/ __token__[/dim]"
-            )
-            self.console.print(
-                "  [dim]4. Ensure keyring-provider is set in pyproject.toml:[/dim]"
-            )
-            self.console.print("  [dim]     [tool.uv][/dim]")
-            self.console.print('  [dim]     keyring-provider = "subprocess"[/dim]')
-
-    def _publish_project(self, options: OptionsProtocol) -> None:
-        if options.publish:
-            self.console.print("\n" + "-" * 80)
-            self.console.print(
-                "[bold bright_cyan]🚀 PUBLISH[/bold bright_cyan] [bold bright_white]Building and publishing package[/bold bright_white]"
-            )
-            self.console.print("-" * 80 + "\n")
-            build = self.execute_command(
-                ["uv", "build"], capture_output=True, text=True
-            )
-            self.console.print(build.stdout)
-            if build.returncode > 0:
-                self.console.print(build.stderr)
-                self.console.print(
-                    "[bold bright_red]❌ Build failed. Please fix errors.[/bold bright_red]"
-                )
-                raise SystemExit(1)
-            try:
-                self._validate_authentication_setup()
-                publish_cmd = self._build_publish_command()
-                self.execute_command(publish_cmd)
-                self._mark_publish_completed()
-                self._clear_state()
-                self.console.print(
-                    "\n[bold bright_green]🏆 Package published successfully![/bold bright_green]"
-                )
-            except SystemExit:
-                self._display_authentication_help()
-                raise
-
-    def _analyze_git_changes(self) -> dict[str, t.Any]:
-        diff_result = self._get_git_diff_output()
-        changes = self._parse_git_diff_output(diff_result)
-        changes["stats"] = self._get_git_stats()
-        return changes
-
-    def _get_git_diff_output(self) -> t.Any:
-        diff_cmd = ["git", "diff", "--cached", "--name-status"]
-        diff_result = self.execute_command(diff_cmd, capture_output=True, text=True)
-        if not diff_result.stdout and diff_result.returncode == 0:
-            diff_cmd = ["git", "diff", "--name-status"]
-            diff_result = self.execute_command(diff_cmd, capture_output=True, text=True)
-        return diff_result
-
-    def _parse_git_diff_output(self, diff_result: t.Any) -> dict[str, t.Any]:
-        changes = {
-            "added": [],
-            "modified": [],
-            "deleted": [],
-            "renamed": [],
-            "total_changes": 0,
-        }
-        if diff_result.returncode == 0 and diff_result.stdout:
-            self._process_diff_lines(diff_result.stdout, changes)
-        return changes
-
-    def _process_diff_lines(self, stdout: str, changes: dict[str, t.Any]) -> None:
-        for line in stdout.strip().split("\n"):
-            if not line:
-                continue
-            self._process_single_diff_line(line, changes)
-
-    def _process_single_diff_line(self, line: str, changes: dict[str, t.Any]) -> None:
-        parts = line.split("\t")
-        if len(parts) >= 2:
-            status, filename = parts[0], parts[1]
-            self._categorize_file_change(status, filename, parts, changes)
-            changes["total_changes"] += 1
-
-    def _categorize_file_change(
-        self, status: str, filename: str, parts: list[str], changes: dict[str, t.Any]
-    ) -> None:
-        if status == "A":
-            changes["added"].append(filename)
-        elif status == "M":
-            changes["modified"].append(filename)
-        elif status == "D":
-            changes["deleted"].append(filename)
-        elif status.startswith("R"):
-            if len(parts) >= 3:
-                changes["renamed"].append((parts[1], parts[2]))
-            else:
-                changes["renamed"].append((filename, "unknown"))
-
-    def _get_git_stats(self) -> str:
-        stat_cmd = ["git", "diff", "--cached", "--stat"]
-        stat_result = self.execute_command(stat_cmd, capture_output=True, text=True)
-        if not stat_result.stdout and stat_result.returncode == 0:
-            stat_cmd = ["git", "diff", "--stat"]
-            stat_result = self.execute_command(stat_cmd, capture_output=True, text=True)
-        return stat_result.stdout if stat_result.returncode == 0 else ""
-
-    def _categorize_changes(self, changes: dict[str, t.Any]) -> dict[str, list[str]]:
-        categories = {
-            "docs": [],
-            "tests": [],
-            "config": [],
-            "core": [],
-            "ci": [],
-            "deps": [],
-        }
-        file_patterns = {
-            "docs": ["README.md", "CLAUDE.md", "RULES.md", "docs/", ".md"],
-            "tests": ["test_", "_test.py", "tests/", "conftest.py"],
-            "config": ["pyproject.toml", ".yaml", ".yml", ".json", ".gitignore"],
-            "ci": [".github/", "ci/", ".pre-commit"],
-            "deps": ["requirements", "pyproject.toml", "uv.lock"],
-        }
-        for file_list in ("added", "modified", "deleted"):
-            for filename in changes.get(file_list, []):
-                categorized = False
-                for category, patterns in file_patterns.items():
-                    if any(pattern in filename for pattern in patterns):
-                        categories[category].append(filename)
-                        categorized = True
-                        break
-                if not categorized:
-                    categories["core"].append(filename)
-
-        return categories
-
-    def _get_primary_changes(self, categories: dict[str, list[str]]) -> list[str]:
-        primary_changes = []
-        category_mapping = [
-            ("core", "core functionality"),
-            ("tests", "tests"),
-            ("docs", "documentation"),
-            ("config", "configuration"),
-            ("deps", "dependencies"),
-        ]
-        for key, label in category_mapping:
-            if categories[key]:
-                primary_changes.append(label)
-
-        return primary_changes or ["project files"]
-
-    def _determine_primary_action(self, changes: dict[str, t.Any]) -> str:
-        added_count = len(changes["added"])
-        modified_count = len(changes["modified"])
-        deleted_count = len(changes["deleted"])
-        if added_count > modified_count + deleted_count:
-            return "Add"
-        elif deleted_count > modified_count + added_count:
-            return "Remove"
-        elif changes["renamed"]:
-            return "Refactor"
-        return "Update"
-
-    def _generate_body_lines(self, changes: dict[str, t.Any]) -> list[str]:
-        body_lines = []
-        change_types = [
-            ("added", "Added"),
-            ("modified", "Modified"),
-            ("deleted", "Deleted"),
-            ("renamed", "Renamed"),
-        ]
-        for change_type, label in change_types:
-            items = changes.get(change_type, [])
-            if items:
-                count = len(items)
-                body_lines.append(f"- {label} {count} file(s)")
-                if change_type not in ("deleted", "renamed"):
-                    for file in items[:3]:
-                        body_lines.append(f"  * {file}")
-                    if count > 3:
-                        body_lines.append(f"  * ... and {count - 3} more")
-
-        return body_lines
-
-    def _generate_commit_message(self, changes: dict[str, t.Any]) -> str:
-        if changes["total_changes"] == 0:
-            return "Update project files"
-        categories = self._categorize_changes(changes)
-        primary_changes = self._get_primary_changes(categories)
-        primary_action = self._determine_primary_action(changes)
-        commit_subject = f"{primary_action} {' and '.join(primary_changes[:2])}"
-        body_lines = self._generate_body_lines(changes)
-        if body_lines:
-            return f"{commit_subject}\n\n" + "\n".join(body_lines)
-        return commit_subject
-
-    def _commit_and_push(self, options: OptionsProtocol) -> None:
-        if options.commit:
-            self.console.print("\n" + "-" * 80)
-            self.console.print(
-                "[bold bright_white]📝 COMMIT[/bold bright_white] [bold bright_white]Saving changes to git[/bold bright_white]"
-            )
-            self.console.print("-" * 80 + "\n")
-            changes = self._analyze_git_changes()
-            if changes["total_changes"] > 0:
-                self.console.print("[dim]🔍 Analyzing changes...[/dim]\n")
-                if changes["stats"]:
-                    self.console.print(changes["stats"])
-                suggested_msg = self._generate_commit_message(changes)
-                self.console.print(
-                    "\n[bold cyan]📋 Suggested commit message:[/bold cyan]"
-                )
-                self.console.print(f"[cyan]{suggested_msg}[/cyan]\n")
-                user_choice = (
-                    input("Use suggested message? [Y/n/e to edit]: ").strip().lower()
-                )
-                if user_choice in ("", "y"):
-                    commit_msg = suggested_msg
-                elif user_choice == "e":
-                    import os
-                    import tempfile
-
-                    with tempfile.NamedTemporaryFile(
-                        mode="w", suffix=".txt", delete=False
-                    ) as f:
-                        f.write(suggested_msg)
-                        temp_path = f.name
-                    editor = os.environ.get("EDITOR", "vi")
-                    self.execute_command([editor, temp_path])
-                    with open(temp_path) as f:
-                        commit_msg = f.read().strip()
-                    Path(temp_path).unlink()
-                else:
-                    commit_msg = input("\nEnter custom commit message: ")
-            else:
-                commit_msg = input("\nCommit message: ")
-            self.execute_command(
-                ["git", "commit", "-m", commit_msg, "--no-verify", "--", "."]
-            )
-            self.execute_command(["git", "push", "origin", "main", "--no-verify"])
-
-    def _update_precommit(self, options: OptionsProtocol) -> None:
-        if options.update_precommit:
-            self.console.print("\n" + "-" * 80)
-            self.console.print(
-                "[bold bright_blue]🔄 UPDATE[/bold bright_blue] [bold bright_white]Updating pre-commit hooks[/bold bright_white]"
-            )
-            self.console.print("-" * 80 + "\n")
-            if self.pkg_path.stem == "crackerjack":
-                update_cmd = ["uv", "run", "pre-commit", "autoupdate"]
-                if getattr(options, "ai_agent", False):
-                    update_cmd.extend(["-c", ".pre-commit-config-ai.yaml"])
-                self.execute_command(update_cmd)
-            else:
-                self.project_manager.update_precommit_hooks()
-
-    def _update_docs(self, options: OptionsProtocol) -> None:
-        if options.update_docs or options.force_update_docs:
-            self.console.print("\n" + "-" * 80)
-            self.console.print(
-                "[bold bright_blue]📋 DOCS UPDATE[/bold bright_blue] [bold bright_white]Updating documentation with quality standards[/bold bright_white]"
-            )
-            self.console.print("-" * 80 + "\n")
-            self.config_manager.copy_documentation_templates(
-                force_update=options.force_update_docs,
-                compress_docs=options.compress_docs,
-            )
-
-    def execute_command(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]:
-        if self.dry_run:
-            self.console.print(
-                f"[bold bright_black]→ {' '.join(cmd)}[/bold bright_black]"
-            )
-            return CompletedProcess(cmd, 0, "", "")
-        return execute(cmd, **kwargs)
-
-    async def execute_command_async(
-        self, cmd: list[str], **kwargs: t.Any
-    ) -> subprocess.CompletedProcess[str]:
-        if self.dry_run:
-            self.console.print(
-                f"[bold bright_black]→ {' '.join(cmd)}[/bold bright_black]"
-            )
-            return CompletedProcess(cmd, 0, "", "")
-
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            **kwargs,
-        )
-        stdout, stderr = await proc.communicate()
-
-        return CompletedProcess(
-            cmd,
-            proc.returncode or 0,
-            stdout.decode() if stdout else "",
-            stderr.decode() if stderr else "",
-        )
-
-    def _run_comprehensive_quality_checks(self, options: OptionsProtocol) -> None:
-        if options.skip_hooks or (
-            options.test
-            and not any([options.publish, options.bump, options.commit, options.all])
-        ):
-            return
-        needs_comprehensive = any(
-            [options.publish, options.bump, options.commit, options.all]
-        )
-        if not needs_comprehensive:
-            return
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_magenta]🔍 COMPREHENSIVE QUALITY[/bold bright_magenta] [bold bright_white]Running all quality checks before publish/commit[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "--hook-stage=manual",
-            "-c",
-            ".pre-commit-config.yaml",
-        ]
-        result = self.execute_command(cmd)
-        if result.returncode > 0:
-            self.console.print(
-                "\n[bold bright_red]❌ Comprehensive quality checks failed![/bold bright_red]"
-            )
-            self.console.print(
-                "\n[bold red]Cannot proceed with publishing/committing until all quality checks pass.[/bold red]\n"
-            )
-            raise SystemExit(1)
-        else:
-            self.console.print(
-                "\n[bold bright_green]🏆 All comprehensive quality checks passed![/bold bright_green]"
-            )
-
-    async def _run_comprehensive_quality_checks_async(
-        self, options: OptionsProtocol
-    ) -> None:
-        if options.skip_hooks or (
-            options.test
-            and not any([options.publish, options.bump, options.commit, options.all])
-        ):
-            return
-
-        needs_comprehensive = any(
-            [options.publish, options.bump, options.commit, options.all]
-        )
-
-        if not needs_comprehensive:
-            return
-
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_magenta]🔍 COMPREHENSIVE QUALITY[/bold bright_magenta] [bold bright_white]Running all quality checks before publish/commit[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "--hook-stage=manual",
-            "-c",
-            ".pre-commit-config.yaml",
-        ]
-
-        result = await self.execute_command_async(cmd)
-
-        if result.returncode > 0:
-            self.console.print(
-                "\n[bold bright_red]❌ Comprehensive quality checks failed![/bold bright_red]"
-            )
-            if result.stderr:
-                self.console.print(f"[dim]Error details: {result.stderr}[/dim]")
-            self.console.print(
-                "\n[bold red]Cannot proceed with publishing/committing until all quality checks pass.[/bold red]\n"
-            )
-            raise SystemExit(1)
-        else:
-            self.console.print(
-                "[bold bright_green]🏆 All comprehensive quality checks passed![/bold bright_green]"
-            )
-
-    def _run_tracked_task(
-        self, task_id: str, task_name: str, task_func: t.Callable[[], None]
-    ) -> None:
-        if self.session_tracker:
-            self.session_tracker.start_task(task_id, task_name)
-        try:
-            task_func()
-            if self.session_tracker:
-                self.session_tracker.complete_task(task_id, f"{task_name} completed")
-        except Exception as e:
-            if self.session_tracker:
-                self.session_tracker.fail_task(task_id, str(e))
-            raise
-
-    def _run_pre_commit_task(self, options: OptionsProtocol) -> None:
-        if not options.skip_hooks:
-            if getattr(options, "ai_agent", False):
-                self.project_manager.run_pre_commit_with_analysis()
-            else:
-                self.project_manager.run_pre_commit()
-        else:
-            self.console.print(
-                "\n[bold bright_yellow]⏭️  Skipping pre-commit hooks...[/bold bright_yellow]\n"
-            )
-            if self.session_tracker:
-                self.session_tracker.skip_task("pre_commit", "Skipped by user request")
-
-    def _initialize_session_tracking(self, options: OptionsProtocol) -> None:
-        if options.resume_from:
-            try:
-                progress_file = Path(options.resume_from)
-                self.session_tracker = SessionTracker.resume_session(
-                    console=self.console,
-                    progress_file=progress_file,
-                )
-                return
-            except Exception as e:
-                self.console.print(
-                    f"[yellow]Warning: Failed to resume from {options.resume_from}: {e}[/yellow]"
-                )
-                self.session_tracker = None
-                return
-        if options.track_progress:
-            try:
-                auto_tracker = SessionTracker.auto_detect_session(self.console)
-                if auto_tracker:
-                    self.session_tracker = auto_tracker
-                    return
-                progress_file = (
-                    Path(options.progress_file) if options.progress_file else None
-                )
-                try:
-                    from importlib.metadata import version
-
-                    crackerjack_version = version("crackerjack")
-                except (ImportError, ModuleNotFoundError):
-                    crackerjack_version = "unknown"
-                metadata = {
-                    "working_dir": str(self.pkg_path),
-                    "python_version": self.python_version,
-                    "crackerjack_version": crackerjack_version,
-                    "cli_options": str(options),
-                }
-                self.session_tracker = SessionTracker.create_session(
-                    console=self.console,
-                    progress_file=progress_file,
-                    metadata=metadata,
-                )
-            except Exception as e:
-                self.console.print(
-                    f"[yellow]Warning: Failed to initialize session tracking: {e}[/yellow]"
-                )
-                self.session_tracker = None
-
-    def process(self, options: OptionsProtocol) -> None:
-        assert self.project_manager is not None
-        self._initialize_session_tracking(options)
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]⚒️ CRACKERJACKING[/bold bright_cyan] [bold bright_white]Starting workflow execution[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        if options.all:
-            options.clean = True
-            options.test = True
-            options.publish = options.all
-            options.commit = True
-        self._run_tracked_task(
-            "setup", "Initialize project structure", self._setup_package
-        )
-        self._run_tracked_task(
-            "update_project",
-            "Update project configuration",
-            lambda: self._update_project(options),
-        )
-        self._run_tracked_task(
-            "update_precommit",
-            "Update pre-commit hooks",
-            lambda: self._update_precommit(options),
-        )
-        self._run_tracked_task(
-            "update_docs",
-            "Update documentation templates",
-            lambda: self._update_docs(options),
-        )
-        self._run_tracked_task(
-            "clean_project", "Clean project code", lambda: self._clean_project(options)
-        )
-        if self.project_manager is not None:
-            self.project_manager.options = options
-        if not options.skip_hooks:
-            self._run_tracked_task(
-                "pre_commit",
-                "Run pre-commit hooks",
-                lambda: self._run_pre_commit_task(options),
-            )
-        else:
-            self._run_pre_commit_task(options)
-        self._run_tracked_task(
-            "run_tests", "Execute test suite", lambda: self._run_tests(options)
-        )
-        self._run_tracked_task(
-            "quality_checks",
-            "Run comprehensive quality checks",
-            lambda: self._run_comprehensive_quality_checks(options),
-        )
-        self._run_tracked_task(
-            "bump_version", "Bump version numbers", lambda: self._bump_version(options)
-        )
-        self._run_tracked_task(
-            "commit_push",
-            "Commit and push changes",
-            lambda: self._commit_and_push(options),
-        )
-        self._run_tracked_task(
-            "publish", "Publish project", lambda: self._publish_project(options)
-        )
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_green]🏆 CRACKERJACK COMPLETE[/bold bright_green] [bold bright_white]Workflow completed successfully![/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-
-    async def process_async(self, options: OptionsProtocol) -> None:
-        assert self.project_manager is not None
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]⚒️ CRACKERJACKING[/bold bright_cyan] [bold bright_white]Starting workflow execution (async optimized)[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        if options.all:
-            options.clean = True
-            options.test = True
-            options.publish = options.all
-            options.commit = True
-        self._setup_package()
-        self._update_project(options)
-        self._update_precommit(options)
-        await self._clean_project_async(options)
-        if self.project_manager is not None:
-            self.project_manager.options = options
-        if not options.skip_hooks:
-            if getattr(options, "ai_agent", False):
-                await self.project_manager.run_pre_commit_with_analysis_async()
-            else:
-                await self.project_manager.run_pre_commit_async()
-        else:
-            self.console.print(
-                "\n[bold bright_yellow]⏭️  Skipping pre-commit hooks...[/bold bright_yellow]\n"
-            )
-        await self._run_tests_async(options)
-        await self._run_comprehensive_quality_checks_async(options)
-        self._bump_version(options)
-        self._commit_and_push(options)
-        self._publish_project(options)
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_green]🏆 CRACKERJACK COMPLETE[/bold bright_green] [bold bright_white]Workflow completed successfully![/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-
-
-crackerjack_it = Crackerjack().process
-
-
-def create_crackerjack_runner(
-    console: Console | None = None,
-    our_path: Path | None = None,
-    pkg_path: Path | None = None,
-    python_version: str = default_python_version,
-    dry_run: bool = False,
-) -> Crackerjack:
-    return Crackerjack(
-        console=console or Console(force_terminal=True),
-        our_path=our_path or Path(__file__).parent,
-        pkg_path=pkg_path or Path.cwd(),
-        python_version=python_version,
-        dry_run=dry_run,
-    )