crackerjack 0.27.0__py3-none-any.whl → 0.27.3__py3-none-any.whl

crackerjack/.gitignore

@@ -29,3 +29,6 @@
 
 # Autotyping cache
 .autotyping-cache/
+
+# Crackerjack state file
+.crackerjack-state

crackerjack/.pre-commit-config.yaml

@@ -91,10 +91,6 @@ repos:
           - --aggressive
           - --only-without-imports
           - --guess-common-names
-          - --cache-dir=.autotyping-cache
-          - --workers=4
-          - --max-line-length=88
-          - --exclude-name=test_*,conftest
           - crackerjack
         types_or: [ python, pyi ]
         language: python
@@ -116,11 +112,3 @@ repos:
     hooks:
       - id: pyright
         stages: [pre-push, manual]
-
-  # Additional quality and security checks
-  - repo: https://github.com/PyCQA/pydocstyle
-    rev: 6.3.0
-    hooks:
-      - id: pydocstyle
-        args: ["--config=pyproject.toml"]
-        stages: [pre-push, manual]

crackerjack/__main__.py

@@ -4,7 +4,8 @@ from enum import Enum
 import typer
 from pydantic import BaseModel, field_validator
 from rich.console import Console
-from crackerjack import create_crackerjack_runner
+
+from .crackerjack import create_crackerjack_runner
 
 console = Console(force_terminal=True)
 app = typer.Typer(
@@ -206,7 +207,7 @@ def main(
 
         os.environ["AI_AGENT"] = "1"
     if interactive:
-        from crackerjack.interactive import launch_interactive_cli
+        from .interactive import launch_interactive_cli
 
         try:
             from importlib.metadata import version

crackerjack/crackerjack.py

@@ -18,7 +18,8 @@ import aiofiles
 from pydantic import BaseModel
 from rich.console import Console
 from tomli_w import dumps
-from crackerjack.errors import ErrorCode, ExecutionError
+
+from .errors import ErrorCode, ExecutionError
 
 
 @dataclass
@@ -361,7 +362,7 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
 
     def remove_docstrings(self, code: str) -> str:
         lines = code.split("\n")
-        cleaned_lines = []
+        cleaned_lines: list[str] = []
         docstring_state = self._initialize_docstring_state()
         for i, line in enumerate(lines):
             handled, result_line = self._process_line(lines, i, line, docstring_state)
@@ -418,7 +419,7 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
 
     def remove_line_comments(self, code: str) -> str:
         lines = code.split("\n")
-        cleaned_lines = []
+        cleaned_lines: list[str] = []
         for line in lines:
             if not line.strip():
                 cleaned_lines.append(line)
@@ -429,7 +430,7 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
         return "\n".join(cleaned_lines)
 
     def _process_line_for_comments(self, line: str) -> str:
-        result = []
+        result: list[str] = []
         string_state = {"in_string": None}
         for i, char in enumerate(line):
             if self._handle_string_character(char, i, line, string_state, result):
@@ -483,7 +484,7 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
 
     def remove_extra_whitespace(self, code: str) -> str:
         lines = code.split("\n")
-        cleaned_lines = []
+        cleaned_lines: list[str] = []
         function_tracker = {"in_function": False, "function_indent": 0}
         import_tracker = {"in_imports": False, "last_import_type": None}
         for i, line in enumerate(lines):
@@ -539,9 +540,15 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
 
         def process_lines():
             lines = code.split("\n")
-            function_tracker = {"in_function": False, "function_indent": 0}
-            import_tracker = {"in_imports": False, "last_import_type": None}
-            previous_lines = []
+            function_tracker: dict[str, t.Any] = {
+                "in_function": False,
+                "function_indent": 0,
+            }
+            import_tracker: dict[str, t.Any] = {
+                "in_imports": False,
+                "last_import_type": None,
+            }
+            previous_lines: list[str] = []
             for i, line in enumerate(lines):
                 line = line.rstrip()
                 stripped_line = line.lstrip()
@@ -854,9 +861,9 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
         from crackerjack.errors import ExecutionError, handle_error
 
         try:
-            async with aiofiles.open(file_path, encoding="utf-8") as f:
-                code = await f.read()
-            original_code = code
+            async with aiofiles.open(file_path, encoding="utf-8") as f:  # type: ignore[misc]
+                code: str = await f.read()  # type: ignore[misc]
+            original_code: str = code
             cleaning_failed = False
             try:
                 code = self.remove_line_comments_streaming(code)
@@ -890,8 +897,8 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
                 )
                 code = original_code
                 cleaning_failed = True
-            async with aiofiles.open(file_path, "w", encoding="utf-8") as f:
-                await f.write(code)
+            async with aiofiles.open(file_path, "w", encoding="utf-8") as f:  # type: ignore[misc]
+                await f.write(code)  # type: ignore[misc]
             if cleaning_failed:
                 self.console.print(
                     f"[bold yellow]⚡ Partially cleaned:[/bold yellow] [dim bright_white]{file_path}[/dim bright_white]"
@@ -965,8 +972,8 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
                 suffix=".py", mode="w+", delete=False
             ) as temp:
                 temp_path = Path(temp.name)
-            async with aiofiles.open(temp_path, "w", encoding="utf-8") as f:
-                await f.write(code)
+            async with aiofiles.open(temp_path, "w", encoding="utf-8") as f:  # type: ignore[misc]
+                await f.write(code)  # type: ignore[misc]
             try:
                 proc = await asyncio.create_subprocess_exec(
                     "uv",
@@ -977,10 +984,10 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                 )
-                stdout, stderr = await proc.communicate()
+                _, stderr = await proc.communicate()
                 if proc.returncode == 0:
-                    async with aiofiles.open(temp_path, encoding="utf-8") as f:
-                        formatted_code = await f.read()
+                    async with aiofiles.open(temp_path, encoding="utf-8") as f:  # type: ignore[misc]
+                        formatted_code = await f.read()  # type: ignore[misc]
                 else:
                     self.console.print(
                         f"[bold bright_yellow]⚠️  Warning: Ruff format failed with return code {proc.returncode}[/bold bright_yellow]"
@@ -1025,7 +1032,7 @@ class CodeCleaner(BaseModel, arbitrary_types_allowed=True):
             return code
 
     async def _cleanup_cache_directories_async(self, pkg_dir: Path) -> None:
-        def cleanup_sync():
+        def cleanup_sync() -> None:
             with suppress(PermissionError, OSError):
                 pycache_dir = pkg_dir / "__pycache__"
                 if pycache_dir.exists():
@@ -1114,7 +1121,9 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
     ) -> None:
         for setting, value in our_config.items():
             if isinstance(value, dict):
-                self._merge_nested_config(setting, value, pkg_config)
+                self._merge_nested_config(
+                    setting, t.cast(dict[str, t.Any], value), pkg_config
+                )
             else:
                 self._merge_direct_config(setting, value, pkg_config)
 
@@ -1133,11 +1142,13 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
         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(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(existing + value))
+                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:
@@ -1147,11 +1158,13 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
         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(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(existing + value))
+                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:
@@ -1171,7 +1184,7 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
     ) -> None:
         python_version_pattern = "\\s*W*(\\d\\.\\d*)"
         requires_python = our_toml_config.get("project", {}).get("requires-python", "")
-        classifiers = []
+        classifiers: list[str] = []
         for classifier in pkg_toml_config.get("project", {}).get("classifiers", []):
             classifier = re.sub(
                 python_version_pattern, f" {self.python_version}", classifier
@@ -1186,7 +1199,7 @@ class ConfigManager(BaseModel, arbitrary_types_allowed=True):
             self.pkg_toml_path.write_text(dumps(pkg_toml_config))
 
     def copy_configs(self) -> None:
-        configs_to_add = []
+        configs_to_add: list[str] = []
         for config in config_files:
             config_path = self.our_path / config
             pkg_config_path = self.pkg_path / config
@@ -1238,7 +1251,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
                 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 files in (py_files, js_files, yaml_files, md_files):
                 for file_path in files:
                     try:
                         total_size += file_path.stat().st_size
@@ -1395,7 +1408,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
         return hook_results
 
     def _parse_hook_output(self, stdout: str, stderr: str) -> list[HookResult]:
-        hook_results = []
+        hook_results: list[HookResult] = []
         lines = stdout.split("\n")
         for line in lines:
             if "..." in line and (
@@ -1482,7 +1495,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
     def _generate_optimization_suggestions(
         self, hook_results: list[HookResult]
     ) -> list[str]:
-        suggestions = []
+        suggestions: list[str] = []
 
         for hook in hook_results:
             if hook.duration > 5.0:
@@ -1578,35 +1591,42 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
     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):
-                    if not complexity_data:
-                        return {
-                            "average_complexity": 0,
-                            "max_complexity": 0,
-                            "total_functions": 0,
-                        }
-                    complexities = [
-                        item.get("complexity", 0)
-                        for item in complexity_data
-                        if isinstance(item, dict)
-                    ]
-                    return {
-                        "average_complexity": sum(complexities) / len(complexities)
-                        if complexities
-                        else 0,
-                        "max_complexity": max(complexities) if complexities else 0,
-                        "total_functions": len(complexities),
-                    }
-                else:
-                    return {
-                        "average_complexity": complexity_data.get("average", 0),
-                        "max_complexity": complexity_data.get("max", 0),
-                        "total_functions": complexity_data.get("total", 0),
-                    }
+                    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"}
 
@@ -1653,7 +1673,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
         return 95.0
 
     def _generate_quality_recommendations(self) -> list[str]:
-        recommendations = []
+        recommendations: list[str] = []
         recommendations.extend(
             [
                 "Consider adding more integration tests",
@@ -1749,22 +1769,20 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
         return "unknown"
 
     def _analyze_directory_structure(self) -> dict[str, t.Any]:
-        directories = []
-        for item in self.pkg_path.iterdir():
-            if item.is_dir() and not item.name.startswith(
-                (".git", "__pycache__", ".venv")
-            ):
-                directories.append(
-                    {
-                        "name": item.name,
-                        "type": self._classify_directory(item),
-                        "file_count": len(list(item.rglob("*"))),
-                    }
-                )
+        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 = {}
+        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(
@@ -1778,17 +1796,15 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
 
     def _analyze_dependencies(self) -> dict[str, t.Any]:
         deps = {"status": "analysis_not_implemented"}
-        try:
+        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"}
-        except Exception:
-            pass
         return deps
 
     def _analyze_configuration_files(self) -> list[str]:
-        config_files = []
+        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)])
@@ -1859,8 +1875,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
             return "hidden"
         elif (directory / "__init__.py").exists():
             return "python_package"
-        else:
-            return "general"
+        return "general"
 
     def _collect_environment_info(self) -> dict[str, t.Any]:
         return {
@@ -1871,7 +1886,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
         }
 
     def _identify_common_issues(self) -> list[str]:
-        issues = []
+        issues: list[str] = []
         if not (self.pkg_path / "pyproject.toml").exists():
             issues.append("Missing pyproject.toml configuration")
         if not (self.pkg_path / ".gitignore").exists():
@@ -2048,6 +2063,58 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
 
         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]"
+            )
+
 
 class Crackerjack(BaseModel, arbitrary_types_allowed=True):
     our_path: Path = Path(__file__).parent
@@ -2062,11 +2129,13 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
     project_manager: ProjectManager | None = 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,
@@ -2087,6 +2156,73 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             dry_run=self.dry_run,
         )
 
+    def _read_state(self) -> dict[str, t.Any]:
+        import json
+
+        if self._state_file.exists():
+            try:
+                return json.loads(self._state_file.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                return {}
+        return {}
+
+    def _write_state(self, state: dict[str, t.Any]) -> None:
+        from contextlib import suppress
+
+        with suppress(OSError):
+            import json
+
+            self._state_file.write_text(json.dumps(state, indent=2), encoding="utf-8")
+
+    def _clear_state(self) -> None:
+        if self._state_file.exists():
+            from contextlib import suppress
+
+            with suppress(OSError):
+                self._state_file.unlink()
+
+    def _has_version_been_bumped(self, version_type: str) -> bool:
+        state = self._read_state()
+        current_version = self._get_current_version()
+        last_bumped_version = state.get("last_bumped_version")
+        last_bump_type = state.get("last_bump_type")
+
+        return (
+            last_bumped_version == current_version
+            and last_bump_type == version_type
+            and not state.get("publish_completed", False)
+        )
+
+    def _mark_version_bumped(self, version_type: str) -> None:
+        current_version = self._get_current_version()
+        state = self._read_state()
+        state.update(
+            {
+                "last_bumped_version": current_version,
+                "last_bump_type": version_type,
+                "publish_completed": False,
+            }
+        )
+        self._write_state(state)
+
+    def _mark_publish_completed(self) -> None:
+        state = self._read_state()
+        state["publish_completed"] = True
+        self._write_state(state)
+
+    def _get_current_version(self) -> str:
+        from contextlib import suppress
+
+        with suppress(Exception):
+            import tomllib
+
+            pyproject_path = Path("pyproject.toml")
+            if pyproject_path.exists():
+                with pyproject_path.open("rb") as f:
+                    data = tomllib.load(f)
+                    return data.get("project", {}).get("version", "unknown")
+        return "unknown"
+
     def _setup_package(self) -> None:
         self.pkg_name = self.pkg_path.stem.lower().replace("-", "_")
         self.pkg_dir = self.pkg_path / self.pkg_name
@@ -2096,11 +2232,14 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             "[bold bright_magenta]🛠️  SETUP[/bold bright_magenta] [bold bright_white]Initializing project structure[/bold bright_white]"
         )
         self.console.print("-" * 80 + "\n")
+        assert self.config_manager is not None
+        assert self.project_manager is not None
         self.config_manager.pkg_name = self.pkg_name
         self.project_manager.pkg_name = self.pkg_name
         self.project_manager.pkg_dir = self.pkg_dir
 
     def _update_project(self, options: t.Any) -> None:
+        assert self.project_manager is not None
         if not options.no_config_updates:
             self.project_manager.update_pkg_configs()
             result: CompletedProcess[str] = self.execute_command(
@@ -2123,6 +2262,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             self.execute_command(update_cmd)
 
     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)
@@ -2142,6 +2282,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                     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)
@@ -2309,31 +2450,38 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
         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 = 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
+            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
-            if len(test_files) > 100 or avg_test_size > 25_000 or slow_test_ratio > 0.4:
-                complexity = "high"
-            elif (
-                len(test_files) > 50 or avg_test_size > 15_000 or slow_test_ratio > 0.2
-            ):
-                complexity = "medium"
-            else:
-                complexity = "low"
-
+            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),
@@ -2354,8 +2502,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             return min(cpu_count // 3, 2)
         elif workload["complexity"] == "medium":
             return min(cpu_count // 2, 4)
-        else:
-            return min(cpu_count, 8)
+        return min(cpu_count, 8)
 
     def _print_ai_agent_files(self, options: t.Any) -> None:
         if getattr(options, "ai_agent", False):
@@ -2422,12 +2569,20 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
     def _bump_version(self, options: OptionsProtocol) -> None:
         for option in (options.publish, options.bump):
             if option:
+                version_type = str(option)
+                if self._has_version_been_bumped(version_type):
+                    self.console.print("\n" + "-" * 80)
+                    self.console.print(
+                        f"[bold yellow]📦 VERSION[/bold yellow] [bold bright_white]Version already bumped ({version_type}), skipping to avoid duplicate bump[/bold bright_white]"
+                    )
+                    self.console.print("-" * 80 + "\n")
+                    return
                 self.console.print("\n" + "-" * 80)
                 self.console.print(
                     f"[bold bright_magenta]📦 VERSION[/bold bright_magenta] [bold bright_white]Bumping {option} version[/bold bright_white]"
                 )
                 self.console.print("-" * 80 + "\n")
-                if str(option) in ("minor", "major"):
+                if version_type in ("minor", "major"):
                     from rich.prompt import Confirm
 
                     if not Confirm.ask(
@@ -2439,6 +2594,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                         )
                         return
                 self.execute_command(["uv", "version", "--bump", option])
+                self._mark_version_bumped(version_type)
                 break
 
     def _publish_project(self, options: OptionsProtocol) -> None:
@@ -2458,7 +2614,18 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                     "[bold bright_red]❌ Build failed. Please fix errors.[/bold bright_red]"
                 )
                 raise SystemExit(1)
-            self.execute_command(["uv", "publish"])
+            try:
+                self.execute_command(["uv", "publish"])
+                self._mark_publish_completed()
+                self._clear_state()
+                self.console.print(
+                    "\n[bold bright_green]✅ Package published successfully![/bold bright_green]"
+                )
+            except SystemExit:
+                self.console.print(
+                    "\n[bold bright_red]❌ Publish failed. Run crackerjack again to retry publishing without re-bumping version.[/bold bright_red]"
+                )
+                raise
 
     def _commit_and_push(self, options: OptionsProtocol) -> None:
         if options.commit:
@@ -2507,7 +2674,98 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
             stderr.decode() if stderr else "",
         )
 
+    def _run_comprehensive_quality_checks(self, options: OptionsProtocol) -> None:
+        if options.skip_hooks or (
+            options.test
+            and not any([options.publish, options.bump, options.commit, options.all])
+        ):
+            return
+        needs_comprehensive = any(
+            [options.publish, options.bump, options.commit, options.all]
+        )
+        if not needs_comprehensive:
+            return
+        self.console.print("\n" + "-" * 80)
+        self.console.print(
+            "[bold bright_magenta]🔍 COMPREHENSIVE QUALITY[/bold bright_magenta] [bold bright_white]Running all quality checks before publish/commit[/bold bright_white]"
+        )
+        self.console.print("-" * 80 + "\n")
+        cmd = [
+            "uv",
+            "run",
+            "pre-commit",
+            "run",
+            "--all-files",
+            "--hook-stage=manual",
+            "-c",
+            ".pre-commit-config.yaml",
+        ]
+        result = self.execute_command(cmd)
+        if result.returncode > 0:
+            self.console.print(
+                "\n[bold bright_red]❌ Comprehensive quality checks failed![/bold bright_red]"
+            )
+            self.console.print(
+                "\n[bold red]Cannot proceed with publishing/committing until all quality checks pass.[/bold red]\n"
+            )
+            raise SystemExit(1)
+        else:
+            self.console.print(
+                "\n[bold bright_green]✅ All comprehensive quality checks passed![/bold bright_green]"
+            )
+
+    async def _run_comprehensive_quality_checks_async(
+        self, options: OptionsProtocol
+    ) -> None:
+        if options.skip_hooks or (
+            options.test
+            and not any([options.publish, options.bump, options.commit, options.all])
+        ):
+            return
+
+        needs_comprehensive = any(
+            [options.publish, options.bump, options.commit, options.all]
+        )
+
+        if not needs_comprehensive:
+            return
+
+        self.console.print("\n" + "-" * 80)
+        self.console.print(
+            "[bold bright_magenta]🔍 COMPREHENSIVE QUALITY[/bold bright_magenta] [bold bright_white]Running all quality checks before publish/commit[/bold bright_white]"
+        )
+        self.console.print("-" * 80 + "\n")
+
+        cmd = [
+            "uv",
+            "run",
+            "pre-commit",
+            "run",
+            "--all-files",
+            "--hook-stage=manual",
+            "-c",
+            ".pre-commit-config.yaml",
+        ]
+
+        result = await self.execute_command_async(cmd)
+
+        if result.returncode > 0:
+            self.console.print(
+                "\n[bold bright_red]❌ Comprehensive quality checks failed![/bold bright_red]"
+            )
+            if result.stderr:
+                self.console.print(f"[dim]Error details: {result.stderr}[/dim]")
+            self.console.print(
+                "\n[bold red]Cannot proceed with publishing/committing until all quality checks pass.[/bold red]\n"
+            )
+            raise SystemExit(1)
+        else:
+            self.console.print(
+                "[bold bright_green]✅ All comprehensive quality checks passed![/bold bright_green]"
+            )
+
     def process(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[/bold bright_white]"
@@ -2533,9 +2791,10 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                 "\n[bold bright_yellow]⏭️  Skipping pre-commit hooks...[/bold bright_yellow]\n"
             )
         self._run_tests(options)
+        self._run_comprehensive_quality_checks(options)
         self._bump_version(options)
-        self._publish_project(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]"
@@ -2543,6 +2802,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
         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]"
@@ -2568,9 +2828,10 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
                 "\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._publish_project(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]"

crackerjack/interactive.py

@@ -85,7 +85,7 @@ class WorkflowManager:
     def add_task(
         self, name: str, description: str, dependencies: list[str] | None = None
     ) -> Task:
-        dep_tasks = []
+        dep_tasks: list[Task] = []
         if dependencies:
             for dep_name in dependencies:
                 if dep_name not in self.tasks:

crackerjack/py313.py

@@ -109,9 +109,13 @@ def process_hook_results[T, R](
     success_handler: typing.Callable[[T], R],
     failure_handler: typing.Callable[[T], R],
 ) -> list[R]:
-    processed_results = []
+    processed_results: list[R] = []
     for result in results:
-        if isinstance(result, dict) and result.get("status") == HookStatus.SUCCESS:
+        if (
+            isinstance(result, dict)
+            and "status" in result
+            and result["status"] == HookStatus.SUCCESS
+        ):
             processed_results.append(success_handler(result))
         else:
             processed_results.append(failure_handler(result))
@@ -156,7 +160,7 @@ class EnhancedCommandRunner:
 
 def clean_python_code(code: str) -> str:
     lines = code.splitlines()
-    cleaned_lines = []
+    cleaned_lines: list[str] = []
     for line in lines:
         match line.strip():
             case "":

crackerjack/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling" ]
 
 [project]
 name = "crackerjack"
-version = "0.26.0"
+version = "0.27.2"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [
@@ -81,19 +81,11 @@ output-format = "full"
 format.docstring-code-format = true
 lint.extend-select = [
     "C901",
-    "D",
     "F",    # pyflakes
     "I",
     "UP",   # pyupgrade (includes F-string conversion)
 ]
 lint.ignore = [
-    "D100", # Missing docstring in public module - can be safely enabled
-    "D101", # Missing docstring in public class - conflicts with code cleaning
-    "D102", # Missing docstring in public method - conflicts with code cleaning
-    "D103", # Missing docstring in public function - conflicts with code cleaning
-    "D104", # Missing docstring in public package - package level docs
-    "D105", # Missing docstring in magic method - conflicts with code cleaning
-    "D107", # Missing docstring in __init__ - conflicts with code cleaning
     "E402", # Module level import not at top - sometimes necessary
     "F821", # Undefined name - can be resolved with proper imports
 ]
@@ -103,7 +95,6 @@ lint.isort.no-lines-before = [
     "first-party",
 ]
 lint.mccabe.max-complexity = 13
-lint.pydocstyle.convention = "google"
 
 [tool.codespell]
 skip = "*/data/*"
@@ -271,15 +262,6 @@ exclude_dirs = [
     "tests/data", # Test data might contain examples
 ]
 
-# Enhanced documentation quality
-
-[tool.pydocstyle]
-convention = "google"
-add-ignore = [
-    "D100", # Missing docstring in public module
-    "D104", # Missing docstring in public package
-]
-
 # Autotyping optimization
 
 [tool.autotyping]

{crackerjack-0.27.0.dist-info → crackerjack-0.27.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.27.0
+Version: 0.27.3
 Summary: Crackerjack: code quality toolkit
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack

crackerjack-0.27.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+crackerjack/.gitignore,sha256=ELNEeIblDM1mKM-LJyj_iLcBzZJPbeJ89YXupvXuLug,498
+crackerjack/.libcst.codemod.yaml,sha256=a8DlErRAIPV1nE6QlyXPAzTOgkB24_spl2E9hphuf5s,772
+crackerjack/.pdm.toml,sha256=dZe44HRcuxxCFESGG8SZIjmc-cGzSoyK3Hs6t4NYA8w,23
+crackerjack/.pre-commit-config-ai.yaml,sha256=-8WIT-6l6crGnQBlX-z3G6-3mKUsBWsURRyeti1ySmI,4267
+crackerjack/.pre-commit-config.yaml,sha256=UgPPAC7O_npBLGJkC_v_2YQUSEIOgsBOXzZjyW2hNvs,2987
+crackerjack/__init__.py,sha256=8tBSPAru_YDuPpjz05cL7pNbZjYFoRT_agGd_FWa3gY,839
+crackerjack/__main__.py,sha256=p7S0GftrU9BHtyqT8q931UtEBoz3n8vPcT1R0OJnS1A,7073
+crackerjack/crackerjack.py,sha256=dPQx3X6lQeGjDaguAJD-IB2knDxAp9payW7v7FBfctY,112736
+crackerjack/errors.py,sha256=Wcv0rXfzV9pHOoXYrhQEjyJd4kUUBbdiY-5M9nI8pDw,4050
+crackerjack/interactive.py,sha256=jnf3klyYFvuQ3u_iVVPshPW1LISfU1VXTOiczTWLxys,16138
+crackerjack/py313.py,sha256=1imwWZUQwcZt09yIrnTSWr73ITTKH8yXlgIe2ESTeLA,5977
+crackerjack/pyproject.toml,sha256=aFoPe_twLd57qFGjeQSYAyzVIi-e8XjT4W9Buyxy91A,6870
+crackerjack-0.27.3.dist-info/METADATA,sha256=naNAMPq4s1yUE3x3kTnKW9dirlYRhDKFWQLgntVY30Q,28788
+crackerjack-0.27.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+crackerjack-0.27.3.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
+crackerjack-0.27.3.dist-info/RECORD,,

crackerjack-0.27.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-crackerjack/.gitignore,sha256=_d0WeGfNZQeCgzJXmjL9LKf-6jjytBulH-ZfWiIOZWI,453
-crackerjack/.libcst.codemod.yaml,sha256=a8DlErRAIPV1nE6QlyXPAzTOgkB24_spl2E9hphuf5s,772
-crackerjack/.pdm.toml,sha256=dZe44HRcuxxCFESGG8SZIjmc-cGzSoyK3Hs6t4NYA8w,23
-crackerjack/.pre-commit-config-ai.yaml,sha256=-8WIT-6l6crGnQBlX-z3G6-3mKUsBWsURRyeti1ySmI,4267
-crackerjack/.pre-commit-config.yaml,sha256=VcK0a32l_OjR-b9hkfXS-eSQORBxsS0QyaVQXPz8jOc,3345
-crackerjack/__init__.py,sha256=8tBSPAru_YDuPpjz05cL7pNbZjYFoRT_agGd_FWa3gY,839
-crackerjack/__main__.py,sha256=4BxL6-o1wrfouAgcXd91eInS2FJiEyhT3a6V5ZfnBWU,7082
-crackerjack/crackerjack.py,sha256=5JZKO_CjbTmiQAVDlso7XSkfTWbs-O80H_3UUEjs79o,102989
-crackerjack/errors.py,sha256=Wcv0rXfzV9pHOoXYrhQEjyJd4kUUBbdiY-5M9nI8pDw,4050
-crackerjack/interactive.py,sha256=pFItgRUyjOakABLCRz6nIp6_Ycx2LBSeojpYNiTelv0,16126
-crackerjack/py313.py,sha256=buYE7LO11Q64ffowEhTZRFQoAGj_8sg3DTlZuv8M9eo,5890
-crackerjack/pyproject.toml,sha256=7lWQyzNq4anXZVpfDmIRkJZc3pXso-LbCHAI4rKnZIw,7647
-crackerjack-0.27.0.dist-info/METADATA,sha256=6HxK2bFU_5w-0-Uxr0LVWaCISHmUOSpzsDiV2XITUes,28788
-crackerjack-0.27.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-crackerjack-0.27.0.dist-info/licenses/LICENSE,sha256=fDt371P6_6sCu7RyqiZH_AhT1LdN3sN1zjBtqEhDYCk,1531
-crackerjack-0.27.0.dist-info/RECORD,,