crackerjack 0.30.3__py3-none-any.whl → 0.31.7__py3-none-any.whl

crackerjack/crackerjack.py

@@ -1,3805 +0,0 @@
-import asyncio
-import json
-import operator
-import re
-import subprocess
-import time
-import typing as t
-from contextlib import suppress
-from dataclasses import dataclass
-from pathlib import Path
-from subprocess import CompletedProcess
-from subprocess import run as execute
-from tomllib import loads
-
-from pydantic import BaseModel
-from rich.console import Console
-from tomli_w import dumps
-
-from .code_cleaner import CodeCleaner
-from .dynamic_config import (
-    generate_config_for_mode,
-)
-
-
-@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",
-    ".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
-    experimental_hooks: bool = False
-    enable_pyrefly: bool = False
-    enable_ty: bool = False
-    no_git_tags: bool = False
-    skip_version_check: bool = False
-
-
-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 _cleanup_legacy_config_files(self) -> None:
-        legacy_config_files = [
-            ".pre-commit-config.yaml",
-            ".pre-commit-config-ai.yaml",
-            ".pre-commit-config-fast.yaml",
-        ]
-        removed_files = []
-        for config_file in legacy_config_files:
-            config_path = Path(config_file)
-            if config_path.exists():
-                try:
-                    config_path.unlink()
-                    removed_files.append(config_file)
-                except OSError as e:
-                    self.console.print(
-                        f"[yellow]Warning: Could not remove {config_file}: {e}[/yellow]"
-                    )
-        if removed_files:
-            self.console.print(
-                f"[dim]🧹 Cleaned up legacy config files: {', '.join(removed_files)}[/dim]"
-            )
-
-    def update_pkg_configs(self) -> None:
-        self._cleanup_legacy_config_files()
-        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"])
-        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"):
-            experimental_hooks = getattr(self.options, "experimental_hooks", False)
-            enable_pyrefly = getattr(self.options, "enable_pyrefly", False)
-            enable_ty = getattr(self.options, "enable_ty", False)
-            enabled_experimental = []
-            if experimental_hooks:
-                enabled_experimental = ["pyrefly", "ty"]
-            else:
-                if enable_pyrefly:
-                    enabled_experimental.append("pyrefly")
-                if enable_ty:
-                    enabled_experimental.append("ty")
-            if enabled_experimental:
-                mode = "experimental"
-                config_path = generate_config_for_mode(mode, enabled_experimental)
-            elif getattr(self.options, "comprehensive", False):
-                mode = "comprehensive"
-                config_path = generate_config_for_mode(mode)
-            else:
-                mode = "fast"
-                config_path = generate_config_for_mode(mode)
-
-            return str(config_path)
-        config_path = generate_config_for_mode("fast")
-        return str(config_path)
-
-    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 _get_state(self) -> dict[str, t.Any]:
-        return self._read_state()
-
-    def _save_state(self, state: dict[str, t.Any]) -> None:
-        self._write_state(state)
-
-    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 _create_git_tag(self, version: str | None = None) -> None:
-        if version is None:
-            version = self._get_current_version()
-        if version == "unknown":
-            self.console.print(
-                "[bold yellow]⚠️  Warning: Could not determine version for tagging[/bold yellow]"
-            )
-            return
-        tag_name = f"v{version}"
-        result = self.execute_command(
-            ["git", "tag", "-l", tag_name], capture_output=True, text=True
-        )
-        if result.stdout.strip():
-            self.console.print(
-                f"[bold yellow]⚠️  Tag {tag_name} already exists, skipping tag creation[/bold yellow]"
-            )
-            return
-        self.console.print(
-            f"[bold bright_cyan]🏷️  Creating git tag: {tag_name}[/bold bright_cyan]"
-        )
-        package_name = self.pkg_path.stem.lower().replace("-", "_")
-        tag_message = f"Release {package_name} v{version}"
-        self.execute_command(["git", "tag", "-a", tag_name, "-m", tag_message])
-        self.console.print(f"[bold green]✅ Created tag: {tag_name}[/bold green]")
-
-    def _push_git_tags(self) -> None:
-        self.console.print(
-            "[bold bright_cyan]🚀 Pushing tags to remote repository[/bold bright_cyan]"
-        )
-        try:
-            self.execute_command(["git", "push", "origin", "--tags"])
-            self.console.print("[bold green]✅ Tags pushed successfully[/bold green]")
-        except Exception as e:
-            self.console.print(
-                f"[bold yellow]⚠️  Warning: Failed to push tags: {e}[/bold yellow]"
-            )
-
-    def _verify_version_consistency(self) -> bool:
-        current_version = self._get_current_version()
-        if current_version == "unknown":
-            self.console.print(
-                "[bold yellow]⚠️  Warning: Could not determine current version from pyproject.toml[/bold yellow]"
-            )
-            return False
-        try:
-            result = self.execute_command(
-                ["git", "describe", "--tags", "--abbrev=0"],
-                capture_output=True,
-                text=True,
-            )
-            latest_tag = result.stdout.strip()
-            if latest_tag.startswith("v"):
-                tag_version = latest_tag[1:]
-            else:
-                tag_version = latest_tag
-        except Exception:
-            self.console.print(
-                "[bold bright_cyan]ℹ️  No git tags found - this appears to be the first release[/bold bright_cyan]"
-            )
-            return True
-        if current_version != tag_version:
-            self.console.print(
-                f"[bold red]❌ Version mismatch detected:[/bold red]\n"
-                f"   pyproject.toml version: {current_version}\n"
-                f"   Latest git tag version: {tag_version}\n"
-                f"   These should match before committing or publishing."
-            )
-            return False
-        self.console.print(
-            f"[bold green]✅ Version consistency verified: {current_version}[/bold green]"
-        )
-        return True
-
-    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()
-            self._run_automatic_updates()
-            if self.pkg_path.stem != "crackerjack":
-                self._check_and_update_crackerjack()
-            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 _run_automatic_updates(self) -> None:
-        self.console.print("[dim]🔄 Checking for updates...[/dim]")
-        self._upgrade_dependencies()
-        self._update_hooks_if_needed()
-
-    def _upgrade_dependencies(self) -> None:
-        try:
-            result = self.execute_command(
-                ["uv", "sync", "--upgrade"], capture_output=True, text=True
-            )
-            if result.returncode == 0:
-                self._handle_upgrade_success(result)
-            else:
-                self.console.print(
-                    f"[yellow]⚠️  Dependency upgrade failed: {result.stderr}[/yellow]"
-                )
-        except Exception as e:
-            self.console.print(f"[yellow]⚠️  Error upgrading dependencies: {e}[/yellow]")
-
-    def _handle_upgrade_success(
-        self, result: "subprocess.CompletedProcess[str]"
-    ) -> None:
-        if "no changes" not in result.stdout.lower():
-            self.console.print("[green]✅ Dependencies upgraded[/green]")
-            self._show_upgrade_summary(result.stdout)
-        else:
-            self.console.print("[dim]✓ Dependencies already up to date[/dim]")
-
-    def _show_upgrade_summary(self, stdout: str) -> None:
-        if stdout.strip():
-            upgrade_lines = [line for line in stdout.split("\n") if "->" in line]
-            if upgrade_lines:
-                self.console.print(f"[dim]{len(upgrade_lines)} packages upgraded[/dim]")
-
-    def _update_hooks_if_needed(self) -> None:
-        import time
-        from pathlib import Path
-
-        marker_file = Path(".crackerjack-hooks-updated")
-        current_time = time.time()
-        week_seconds = 7 * 24 * 60 * 60
-        should_update = True
-        if marker_file.exists():
-            try:
-                last_update = float(marker_file.read_text().strip())
-                if current_time - last_update < week_seconds:
-                    should_update = False
-            except (ValueError, OSError):
-                should_update = True
-        if should_update:
-            self._update_precommit_hooks()
-            from contextlib import suppress
-
-            with suppress(OSError):
-                marker_file.write_text(str(current_time))
-        else:
-            self.console.print("[dim]✓ Pre-commit hooks recently updated[/dim]")
-
-    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:
-                if "updated" in result.stdout.lower():
-                    self.console.print("[green]✅ Pre-commit hooks updated[/green]")
-                    update_lines = [
-                        line for line in result.stdout.split("\n") if "->" in line
-                    ]
-                    if update_lines:
-                        self.console.print(
-                            f"[dim]{len(update_lines)} hooks updated[/dim]"
-                        )
-                else:
-                    self.console.print(
-                        "[dim]✓ Pre-commit hooks already up to date[/dim]"
-                    )
-            else:
-                self.console.print(
-                    f"[yellow]⚠️  Pre-commit update failed: {result.stderr}[/yellow]"
-                )
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️  Error updating pre-commit hooks: {e}[/yellow]"
-            )
-
-    def _check_and_update_crackerjack(self) -> None:
-        try:
-            import tomllib
-            from pathlib import Path
-
-            pyproject_path = Path("pyproject.toml")
-            if not pyproject_path.exists():
-                return
-            with pyproject_path.open("rb") as f:
-                config = tomllib.load(f)
-            dependencies = config.get("project", {}).get("dependencies", [])
-            dev_dependencies = config.get("dependency-groups", {}).get("dev", [])
-            has_crackerjack = any(
-                dep.startswith("crackerjack") for dep in dependencies + dev_dependencies
-            )
-            if has_crackerjack:
-                result = self.execute_command(
-                    ["uv", "sync", "--upgrade", "--upgrade-package", "crackerjack"],
-                    capture_output=True,
-                    text=True,
-                )
-                if result.returncode == 0:
-                    if "crackerjack" in result.stdout:
-                        self.console.print(
-                            "[green]✅ Crackerjack upgraded to latest version[/green]"
-                        )
-                    else:
-                        self.console.print(
-                            "[dim]✓ Crackerjack already up to date[/dim]"
-                        )
-                else:
-                    self.console.print(
-                        f"[yellow]⚠️  Crackerjack update check failed: {result.stderr}[/yellow]"
-                    )
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️  Error checking crackerjack updates: {e}[/yellow]"
-            )
-
-    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 _prompt_version_selection(self) -> str:
-        from rich.prompt import Prompt
-
-        if self.options and getattr(self.options, "ai_agent", False):
-            self.console.print(
-                "[dim]AI agent mode: defaulting to patch version bump[/dim]"
-            )
-            return "patch"
-        self.console.print(
-            "\n[bold bright_yellow]📦 VERSION SELECTION[/bold bright_yellow]"
-        )
-        self.console.print("[dim]Select the type of version bump to perform:[/dim]\n")
-        choices = {
-            "1": ("patch", "Bug fixes and minor changes (0.1.0 → 0.1.1)"),
-            "2": ("minor", "New features, backwards compatible (0.1.0 → 0.2.0)"),
-            "3": ("major", "Breaking changes, major updates (0.1.0 → 1.0.0)"),
-        }
-        for key, (bump_type, description) in choices.items():
-            self.console.print(
-                f"  [bold bright_cyan]{key}[/bold bright_cyan] {bump_type:<6} - {description}"
-            )
-        while True:
-            choice = Prompt.ask(
-                "\n[bold]Select version bump type",
-                choices=list(choices.keys()),
-                default="1",
-                show_choices=False,
-            )
-            if choice in choices:
-                selected_type = choices[choice][0]
-                self.console.print(
-                    f"[green]✓ Selected: {selected_type} version bump[/green]"
-                )
-                return selected_type
-            else:
-                self.console.print(
-                    "[red]Invalid choice. Please select 1, 2, or 3.[/red]"
-                )
-
-    def _bump_version(self, options: OptionsProtocol) -> None:
-        if options.publish and str(options.publish) == "interactive":
-            return self._handle_interactive_version_selection(options)
-        for option in (options.publish, options.bump):
-            if option:
-                version_type = str(option)
-                if self._has_version_been_bumped(version_type):
-                    self._display_version_already_bumped_message(version_type)
-                    return
-                self._display_version_bump_message(option)
-                if not self._confirm_version_bump_if_needed(option, version_type):
-                    return
-                self.execute_command(["uv", "version", "--bump", option])
-                self._mark_version_bumped(version_type)
-                if not options.no_git_tags:
-                    self._create_git_tag()
-                break
-
-    def _handle_interactive_version_selection(self, options: OptionsProtocol) -> None:
-        selected_version = self._prompt_version_selection()
-        from crackerjack.__main__ import BumpOption
-
-        options_dict = vars(options).copy()
-        options_dict["publish"] = BumpOption(selected_version)
-        from types import SimpleNamespace
-
-        temp_options = SimpleNamespace(**options_dict)
-
-        return self._bump_version(temp_options)  # type: ignore[arg-type]
-
-    def _display_version_already_bumped_message(self, version_type: str) -> None:
-        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")
-
-    def _display_version_bump_message(self, option: t.Any) -> None:
-        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")
-
-    def _confirm_version_bump_if_needed(self, option: t.Any, version_type: str) -> bool:
-        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 False
-        return True
-
-    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 _publish_with_retry(self) -> None:
-        max_retries = 2
-        for attempt in range(max_retries):
-            try:
-                result = self._attempt_publish()
-                if result.returncode == 0:
-                    self._verify_pypi_upload()
-                    return
-                if not self._handle_publish_failure(result, attempt, max_retries):
-                    raise SystemExit(1)
-            except SystemExit:
-                if attempt < max_retries - 1:
-                    continue
-                raise
-
-    def _attempt_publish(self) -> "subprocess.CompletedProcess[str]":
-        self._validate_authentication_setup()
-        publish_cmd = self._build_publish_command()
-        self.console.print("[dim]📤 Uploading package to PyPI...[/dim]")
-        import subprocess
-        import time
-        from threading import Thread
-
-        from rich.live import Live
-        from rich.spinner import Spinner
-
-        result: subprocess.CompletedProcess[str] | None = None
-        start_time = time.time()
-
-        def run_publish() -> None:
-            nonlocal result
-            result = self.execute_command(publish_cmd, capture_output=True, text=True)
-
-        publish_thread = Thread(target=run_publish)
-        publish_thread.start()
-
-        elapsed_time = 0
-        while publish_thread.is_alive():
-            elapsed_time = time.time() - start_time
-
-            if elapsed_time < 5:
-                text = "[dim]📤 Uploading to PyPI...[/dim]"
-            elif elapsed_time < 15:
-                text = "[dim]📤 Uploading to PyPI... (this may take a moment)[/dim]"
-            else:
-                text = "[dim]📤 Uploading to PyPI... (large package or slow connection)[/dim]"
-
-            spinner = Spinner("dots", text=text)
-            with Live(spinner, refresh_per_second=10, transient=True):
-                time.sleep(0.5)
-
-            if not publish_thread.is_alive():
-                break
-
-        publish_thread.join()
-
-        elapsed_time = time.time() - start_time
-
-        if result and result.returncode == 0:
-            self.console.print(
-                f"[green]✅ Package uploaded successfully! ({elapsed_time:.1f}s)[/green]"
-            )
-        elif result and result.returncode != 0:
-            self.console.print(f"[red]❌ Upload failed after {elapsed_time:.1f}s[/red]")
-            if result.stdout:
-                self.console.print(f"[dim]stdout: {result.stdout}[/dim]")
-            if result.stderr:
-                self.console.print(f"[red]stderr: {result.stderr}[/red]")
-
-        if result is None:
-            return subprocess.CompletedProcess(
-                args=publish_cmd,
-                returncode=1,
-                stdout="",
-                stderr="Thread execution failed",
-            )
-
-        return result
-
-    def _verify_pypi_upload(self) -> None:
-        if self.options and getattr(self.options, "ai_agent", False):
-            return
-        import time
-
-        package_name = self._get_package_name()
-        current_version = self._get_current_version()
-        self.console.print(
-            f"[dim]🔍 Verifying upload of {package_name} v{current_version}...[/dim]"
-        )
-        time.sleep(2)
-        self._retry_pypi_verification(package_name, current_version)
-
-    def _retry_pypi_verification(self, package_name: str, current_version: str) -> None:
-        import time
-
-        max_attempts = 3
-        for attempt in range(max_attempts):
-            try:
-                if self._check_pypi_package_exists(package_name, current_version):
-                    self._show_pypi_success(package_name, current_version)
-                    return
-                if attempt < max_attempts - 1:
-                    self._show_pypi_retry_message(attempt, max_attempts)
-                    time.sleep(5)
-                    continue
-                else:
-                    self._show_pypi_not_visible(package_name, current_version)
-                    return
-            except Exception as e:
-                if attempt < max_attempts - 1:
-                    self._show_pypi_error_retry(attempt, max_attempts, e)
-                    time.sleep(5)
-                    continue
-                else:
-                    self._show_pypi_final_error(package_name, current_version, e)
-                    return
-
-    def _check_pypi_package_exists(
-        self, package_name: str, current_version: str
-    ) -> bool:
-        import json
-        import urllib.error
-        import urllib.request
-
-        url = f"https://pypi.org/pypi/{package_name}/{current_version}/json"
-        try:
-            with urllib.request.urlopen(url, timeout=10) as response:  # nosec B310
-                data = json.loads(response.read().decode())
-                return data.get("info", {}).get("version") == current_version
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                return False
-            raise
-
-    def _show_pypi_success(self, package_name: str, current_version: str) -> None:
-        self.console.print(
-            f"[green]✅ Verified: {package_name} v{current_version} is available on PyPI![/green]"
-        )
-        pypi_url = f"https://pypi.org/project/{package_name}/{current_version}/"
-        self.console.print(f"[dim]   📦 Package URL: {pypi_url}[/dim]")
-
-    def _show_pypi_retry_message(self, attempt: int, max_attempts: int) -> None:
-        self.console.print(
-            f"[yellow]⏳ Package not yet available on PyPI (attempt {attempt + 1}/{max_attempts}), retrying...[/yellow]"
-        )
-
-    def _show_pypi_not_visible(self, package_name: str, current_version: str) -> None:
-        self.console.print(
-            "[yellow]⚠️  Package uploaded but not yet visible on PyPI (this is normal)[/yellow]"
-        )
-        self.console.print(
-            f"[dim]   Check later at: https://pypi.org/project/{package_name}/{current_version}/[/dim]"
-        )
-
-    def _show_pypi_error_retry(
-        self, attempt: int, max_attempts: int, error: Exception
-    ) -> None:
-        self.console.print(
-            f"[yellow]⏳ Error checking PyPI (attempt {attempt + 1}/{max_attempts}): {error}[/yellow]"
-        )
-
-    def _show_pypi_final_error(
-        self, package_name: str, current_version: str, error: Exception
-    ) -> None:
-        self.console.print(f"[yellow]⚠️  Could not verify PyPI upload: {error}[/yellow]")
-        self.console.print(
-            f"[dim]   Check manually at: https://pypi.org/project/{package_name}/{current_version}/[/dim]"
-        )
-
-    def _get_package_name(self) -> str:
-        import tomllib
-        from pathlib import Path
-
-        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("name", "unknown")
-        return "unknown"
-
-    def _handle_publish_failure(
-        self, result: "subprocess.CompletedProcess[str]", attempt: int, max_retries: int
-    ) -> bool:
-        if self._is_auth_error(result):
-            return self._handle_auth_error(attempt, max_retries)
-        else:
-            self._handle_non_auth_error(result)
-            return False
-
-    def _handle_auth_error(self, attempt: int, max_retries: int) -> bool:
-        if attempt < max_retries - 1:
-            self.console.print(
-                f"[yellow]⚠️  Authentication failed (attempt {attempt + 1}/{max_retries})[/yellow]"
-            )
-            return self._prompt_for_token()
-        self._display_authentication_help()
-        return False
-
-    def _handle_non_auth_error(
-        self, result: "subprocess.CompletedProcess[str]"
-    ) -> None:
-        self.console.print(result.stdout)
-        self.console.print(result.stderr)
-
-    def _is_auth_error(self, result: "subprocess.CompletedProcess[str]") -> bool:
-        error_text = (result.stdout + result.stderr).lower()
-        auth_indicators = (
-            "authentication",
-            "unauthorized",
-            "403",
-            "401",
-            "invalid credentials",
-            "token",
-            "password",
-            "username",
-        )
-        return any(indicator in error_text for indicator in auth_indicators)
-
-    def _prompt_for_token(self) -> bool:
-        import getpass
-        import os
-        import shutil
-
-        if self.options and getattr(self.options, "ai_agent", False):
-            return False
-        self.console.print("\n[bold yellow]🔐 PyPI Token Required[/bold yellow]")
-        self.console.print(
-            "[dim]Please enter your PyPI token (starts with 'pypi-'):[/dim]"
-        )
-        try:
-            token = getpass.getpass("PyPI Token: ")
-            if not token or not token.startswith("pypi-"):
-                self.console.print(
-                    "[red]❌ Invalid token format. Token must start with 'pypi-'[/red]"
-                )
-                return False
-            if shutil.which("keyring"):
-                try:
-                    result = self.execute_command(
-                        [
-                            "keyring",
-                            "set",
-                            "https://upload.pypi.org/legacy/",
-                            "__token__",
-                        ],
-                        input=token,
-                        capture_output=True,
-                        text=True,
-                    )
-                    if result.returncode == 0:
-                        self.console.print("[green]✅ Token stored in keyring[/green]")
-                    else:
-                        os.environ["UV_PUBLISH_TOKEN"] = token
-                        self.console.print(
-                            "[yellow]⚠️  Keyring storage failed, using environment variable[/yellow]"
-                        )
-                except Exception:
-                    os.environ["UV_PUBLISH_TOKEN"] = token
-                    self.console.print(
-                        "[yellow]⚠️  Keyring storage failed, using environment variable[/yellow]"
-                    )
-            else:
-                os.environ["UV_PUBLISH_TOKEN"] = token
-                self.console.print(
-                    "[yellow]⚠️  Keyring not available, using environment variable[/yellow]"
-                )
-
-            return True
-        except KeyboardInterrupt:
-            self.console.print("\n[yellow]⚠️  Token entry cancelled[/yellow]")
-            return False
-        except Exception as e:
-            self.console.print(f"[red]❌ Error storing token: {e}[/red]")
-            return False
-
-    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")
-            if not options.skip_version_check:
-                if not self._verify_version_consistency():
-                    self.console.print(
-                        "[bold red]❌ Publishing aborted due to version mismatch. Please ensure pyproject.toml version matches git tag.[/bold red]"
-                    )
-                    raise SystemExit(1)
-            state = self._get_state()
-            if not state.get("build_completed", False):
-                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)
-                state["build_completed"] = True
-                self._save_state(state)
-            else:
-                self.console.print(
-                    "[dim]📦 Using existing build artifacts (retry mode)[/dim]"
-                )
-            self._publish_with_retry()
-            self._mark_publish_completed()
-            self._clear_state()
-            self.console.print(
-                "\n[bold bright_green]🏆 Package published successfully![/bold bright_green]"
-            )
-
-    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")
-            if not options.skip_version_check:
-                if not self._verify_version_consistency():
-                    self.console.print(
-                        "[bold red]❌ Commit aborted due to version mismatch. Please ensure pyproject.toml version matches git tag.[/bold red]"
-                    )
-                    raise SystemExit(1)
-            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"])
-            self._push_git_tags()
-
-    def _update_precommit(self, options: OptionsProtocol) -> None:
-        if options.update_precommit:
-            self.console.print(
-                "\n[bold yellow]⚠️  DEPRECATION WARNING[/bold yellow]: The --update-precommit (-u) flag is deprecated.\n"
-                "   Pre-commit hooks are now updated automatically on a weekly basis.\n"
-                "   This manual update will still work but is no longer needed.\n"
-            )
-            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":
-                config_path = self.project_manager._select_precommit_config()
-                update_cmd = [
-                    "uv",
-                    "run",
-                    "pre-commit",
-                    "autoupdate",
-                    "-c",
-                    config_path,
-                ]
-                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")
-        config_path = self.project_manager._select_precommit_config()
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "--hook-stage=manual",
-            "-c",
-            config_path,
-        ]
-        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")
-
-        config_path = self.project_manager._select_precommit_config()
-        cmd = [
-            "uv",
-            "run",
-            "pre-commit",
-            "run",
-            "--all-files",
-            "--hook-stage=manual",
-            "-c",
-            config_path,
-        ]
-
-        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, "comprehensive", False):
-                self._run_comprehensive_hooks()
-            elif 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 _run_comprehensive_hooks(self) -> None:
-        self.console.print("\n" + "-" * 80)
-        self.console.print(
-            "[bold bright_cyan]🔍 HOOKS[/bold bright_cyan] [bold bright_white]Running comprehensive quality checks[/bold bright_white]"
-        )
-        self.console.print("-" * 80 + "\n")
-        stages = ["pre-commit", "pre-push", "manual"]
-        config_path = self.project_manager._select_precommit_config()
-        for stage in stages:
-            self.console.print(f"[dim]Running {stage} stage hooks...[/dim]")
-            cmd = [
-                "uv",
-                "run",
-                "pre-commit",
-                "run",
-                "--all-files",
-                f"--hook-stage={stage}",
-                "-c",
-                config_path,
-            ]
-            result = self.execute_command(cmd)
-            if result.returncode > 0:
-                self.console.print(
-                    f"\n[bold red]❌ {stage} hooks failed. Please fix errors.[/bold red]\n"
-                )
-                raise SystemExit(1)
-
-    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
-        if options.comprehensive:
-            options.test = 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
-        if options.comprehensive:
-            options.test = 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,
-    )