crackerjack 0.21.0__tar.gz → 0.21.2__tar.gz

{crackerjack-0.21.0 → crackerjack-0.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crackerjack
-Version: 0.21.0
+Version: 0.21.2
 Summary: Crackerjack: code quality toolkit
 Keywords: bandit,black,creosote,mypy,pyright,pytest,refurb,ruff
 Author-Email: lesleslie <les@wedgwoodwebworks.com>

crackerjack-0.21.2/crackerjack/.pre-commit-config-ai.yaml

@@ -0,0 +1,135 @@
+repos:
+  # File structure and format validators - check structure first
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+        name: trailing-whitespace
+        verbose: true
+      - id: end-of-file-fixer
+        name: end-of-file-fixer
+        verbose: true
+      - id: check-yaml
+        name: check-yaml
+        verbose: true
+      - id: check-toml
+        name: check-toml
+        verbose: true
+      - id: check-added-large-files
+        name: check-added-large-files
+        verbose: true
+
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.24.1
+    hooks:
+      - id: validate-pyproject
+        verbose: true
+
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: "v2.6.0"
+    hooks:
+      - id: pyproject-fmt
+        verbose: true
+
+  # Package management - once structure is valid
+  - repo: https://github.com/pdm-project/pdm
+    rev: 2.25.3
+    hooks:
+      - id: pdm-lock-check
+        verbose: true
+      - id: pdm-sync
+        verbose: true
+        additional_dependencies:
+          - keyring
+
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.7.15
+    hooks:
+      - id: uv-lock
+        files: ^pyproject\.toml$
+        verbose: true
+
+  # Security check - early to prevent credential leaks
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.5.0
+    hooks:
+      - id: detect-secrets
+        exclude: 'pdm\.lock|uv\.lock|pyproject\.toml|tests/.*|docs/.*|.*\.md'
+        verbose: true
+
+  # Code quality tier 1 - quick fixes
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.1
+    hooks:
+      - id: codespell
+        verbose: true
+        additional_dependencies:
+          - tomli
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.1
+    hooks:
+      - id: ruff-check
+        verbose: true
+        args: [--output-format=json]
+      - id: ruff-format
+        verbose: true
+
+  # Code quality tier 2 - analysis
+  - repo: https://github.com/jendrikseipp/vulture
+    rev: 'v2.14'
+    hooks:
+      - id: vulture
+        verbose: true
+
+  - repo: https://github.com/fredrikaverpil/creosote
+    rev: v4.0.3
+    hooks:
+      - id: creosote
+        verbose: true
+
+  - repo: https://github.com/rohaquinlop/complexipy-pre-commit
+    rev: v3.0.0
+    hooks:
+      - id: complexipy
+        args: ["-d", "low", "-j"]
+        verbose: true
+
+  - repo: https://github.com/dosisod/refurb
+    rev: v2.1.0
+    hooks:
+      - id: refurb
+        verbose: true
+
+  # Code quality tier 3 - thorough checks
+  - repo: local
+    hooks:
+      - id: autotyping
+        name: autotyping
+        entry: python -m autotyping
+        args:
+          - --aggressive
+          - --only-without-imports
+          - --guess-common-names
+          - crackerjack
+        types_or: [ python, pyi ]
+        language: python
+        files: \.py$
+        verbose: true
+        additional_dependencies:
+          - autotyping>=24.3.0
+          - libcst>=1.1.0
+
+  - repo: https://github.com/PyCQA/bandit
+    rev: '1.8.5'
+    hooks:
+      - id: bandit
+        args: ["-c", "pyproject.toml", "--format", "json"]
+        verbose: true
+
+  - repo: https://github.com/RobertCraigie/pyright-python
+    rev: v1.1.402
+    hooks:
+      - id: pyright
+        verbose: true
+        args: ["--outputjson"]

{crackerjack-0.21.0 → crackerjack-0.21.2}/crackerjack/crackerjack.py

@@ -12,7 +12,12 @@ from rich.console import Console
 from tomli_w import dumps
 from crackerjack.errors import ErrorCode, ExecutionError
 
-config_files = (".gitignore", ".pre-commit-config.yaml", ".libcst.codemod.yaml")
+config_files = (
+    ".gitignore",
+    ".pre-commit-config.yaml",
+    ".pre-commit-config-ai.yaml",
+    ".libcst.codemod.yaml",
+)
 default_python_version = "3.13"
 
 
@@ -534,20 +539,7 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
     code_cleaner: CodeCleaner
     config_manager: ConfigManager
     dry_run: bool = False
-
-    def run_interactive(self, hook: str) -> None:
-        success: bool = False
-        while not success:
-            fail = self.execute_command(
-                ["pre-commit", "run", hook.lower(), "--all-files"]
-            )
-            if fail.returncode > 0:
-                retry = input(f"\n\n{hook.title()} failed. Retry? (y/N): ")
-                self.console.print()
-                if retry.strip().lower() == "y":
-                    continue
-                raise SystemExit(1)
-            success = True
+    options: t.Any = None
 
     def update_pkg_configs(self) -> None:
         self.config_manager.copy_configs()
@@ -562,15 +554,21 @@ class ProjectManager(BaseModel, arbitrary_types_allowed=True):
             self.execute_command(["git", "branch", "-m", "main"])
             self.execute_command(["git", "add", "pyproject.toml"])
             self.execute_command(["git", "add", "pdm.lock"])
-            self.execute_command(["pre-commit", "install"])
+            install_cmd = ["pre-commit", "install"]
+            if hasattr(self, "options") and getattr(self.options, "ai_agent", False):
+                install_cmd.extend(["-c", ".pre-commit-config-ai.yaml"])
+            self.execute_command(install_cmd)
             self.execute_command(["git", "config", "advice.addIgnoredFile", "false"])
         self.config_manager.update_pyproject_configs()
 
     def run_pre_commit(self) -> None:
         self.console.print("\nRunning pre-commit hooks...\n")
-        check_all = self.execute_command(["pre-commit", "run", "--all-files"])
+        cmd = ["pre-commit", "run", "--all-files"]
+        if hasattr(self, "options") and getattr(self.options, "ai_agent", False):
+            cmd.extend(["-c", ".pre-commit-config-ai.yaml"])
+        check_all = self.execute_command(cmd)
         if check_all.returncode > 0:
-            check_all = self.execute_command(["pre-commit", "run", "--all-files"])
+            check_all = self.execute_command(cmd)
             if check_all.returncode > 0:
                 self.console.print("\n\nPre-commit failed. Please fix errors.\n")
                 raise SystemExit(1)
@@ -644,7 +642,10 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
 
     def _update_precommit(self, options: t.Any) -> None:
         if self.pkg_path.stem == "crackerjack" and options.update_precommit:
-            self.execute_command(["pre-commit", "autoupdate"])
+            update_cmd = ["pre-commit", "autoupdate"]
+            if options.ai_agent:
+                update_cmd.extend(["-c", ".pre-commit-config-ai.yaml"])
+            self.execute_command(update_cmd)
 
     def _clean_project(self, options: t.Any) -> None:
         if options.clean:
@@ -736,6 +737,17 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
     def _bump_version(self, options: OptionsProtocol) -> None:
         for option in (options.publish, options.bump):
             if option:
+                if str(option) 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"[yellow]Skipping {option} version bump[/yellow]"
+                        )
+                        return
                 self.execute_command(["pdm", "bump", option])
                 break
 
@@ -777,6 +789,7 @@ class Crackerjack(BaseModel, arbitrary_types_allowed=True):
         self._update_project(options)
         self._update_precommit(options)
         self._clean_project(options)
+        self.project_manager.options = options
         if not options.skip_hooks:
             self.project_manager.run_pre_commit()
         else:

{crackerjack-0.21.0 → crackerjack-0.21.2}/crackerjack/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "pdm-backend" ]
 
 [project]
 name = "crackerjack"
-version = "0.20.20"
+version = "0.21.1"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.21.0 → crackerjack-0.21.2}/pyproject.toml

@@ -6,7 +6,7 @@ requires = [
 
 [project]
 name = "crackerjack"
-version = "0.21.0"
+version = "0.21.2"
 description = "Crackerjack: code quality toolkit"
 readme = "README.md"
 keywords = [

{crackerjack-0.21.0 → crackerjack-0.21.2}/tests/test_crackerjack.py

@@ -287,20 +287,111 @@ class TestCrackerjackProcess:
         mock_project_manager_execute.return_value.returncode = 0
         mock_config_manager_execute.return_value.returncode = 0
         options = options_factory(bump="minor", no_config_updates=True)
-        with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
-            mock_cj_execute.return_value = MagicMock(returncode=0, stdout="Success")
-            with patch.object(Crackerjack, "_update_project") as mock_update_project:
-                mock_update_project.side_effect = lambda opts: mock_console_print(
-                    "Skipping config updates."
-                )
-                cj = Crackerjack(dry_run=True)
-                cj.process(options)
-                mock_cj_execute.assert_any_call(["pdm", "bump", "minor"])
-        console_print_calls = [str(call) for call in mock_console_print.call_args_list]
+        with patch("rich.prompt.Confirm.ask", return_value=True):
+            with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
+                mock_cj_execute.return_value = MagicMock(returncode=0, stdout="Success")
+                with patch.object(
+                    Crackerjack, "_update_project"
+                ) as mock_update_project:
+                    mock_update_project.side_effect = lambda opts: mock_console_print(
+                        "Skipping config updates."
+                    )
+                    cj = Crackerjack(dry_run=True)
+                    cj.process(options)
+                    mock_cj_execute.assert_any_call(["pdm", "bump", "minor"])
+            console_print_calls = [
+                str(call) for call in mock_console_print.call_args_list
+            ]
         assert any("Skipping config updates" in call for call in console_print_calls), (
             "Expected 'Skipping config updates' message was not printed"
         )
 
+    def test_bump_version_confirmation_minor_accepted(
+        self,
+        mock_execute: MagicMock,
+        mock_console_print: MagicMock,
+        tmp_path: Path,
+        tmp_path_package: Path,
+        create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
+    ) -> None:
+        options = options_factory(bump="minor", no_config_updates=True)
+        cj = Crackerjack(dry_run=True)
+
+        with patch("rich.prompt.Confirm.ask", return_value=True) as mock_confirm:
+            with patch.object(Crackerjack, "execute_command") as mock_exec:
+                mock_exec.return_value = MagicMock(returncode=0)
+                cj._bump_version(options)
+
+                mock_confirm.assert_called_once_with(
+                    "Are you sure you want to bump the minor version?", default=False
+                )
+                mock_exec.assert_called_once_with(["pdm", "bump", "minor"])
+
+    def test_bump_version_confirmation_minor_declined(
+        self,
+        mock_execute: MagicMock,
+        mock_console_print: MagicMock,
+        tmp_path: Path,
+        tmp_path_package: Path,
+        create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
+    ) -> None:
+        options = options_factory(bump="minor", no_config_updates=True)
+        cj = Crackerjack(dry_run=True)
+
+        with patch("rich.prompt.Confirm.ask", return_value=False) as mock_confirm:
+            with patch.object(Crackerjack, "execute_command") as mock_exec:
+                mock_exec.return_value = MagicMock(returncode=0)
+                cj._bump_version(options)
+
+                mock_confirm.assert_called_once_with(
+                    "Are you sure you want to bump the minor version?", default=False
+                )
+                mock_exec.assert_not_called()
+
+    def test_bump_version_confirmation_major(
+        self,
+        mock_execute: MagicMock,
+        mock_console_print: MagicMock,
+        tmp_path: Path,
+        tmp_path_package: Path,
+        create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
+    ) -> None:
+        options = options_factory(bump="major", no_config_updates=True)
+        cj = Crackerjack(dry_run=True)
+
+        with patch("rich.prompt.Confirm.ask", return_value=True) as mock_confirm:
+            with patch.object(Crackerjack, "execute_command") as mock_exec:
+                mock_exec.return_value = MagicMock(returncode=0)
+                cj._bump_version(options)
+
+                mock_confirm.assert_called_once_with(
+                    "Are you sure you want to bump the major version?", default=False
+                )
+                mock_exec.assert_called_once_with(["pdm", "bump", "major"])
+
+    def test_bump_version_no_confirmation_micro(
+        self,
+        mock_execute: MagicMock,
+        mock_console_print: MagicMock,
+        tmp_path: Path,
+        tmp_path_package: Path,
+        create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
+    ) -> None:
+        options = options_factory(bump="micro", no_config_updates=True)
+        cj = Crackerjack(dry_run=True)
+
+        with patch("rich.prompt.Confirm.ask") as mock_confirm:
+            with patch.object(Crackerjack, "execute_command") as mock_exec:
+                mock_exec.return_value = MagicMock(returncode=0)
+                cj._bump_version(options)
+
+                mock_confirm.assert_not_called()
+                mock_exec.assert_called_once_with(["pdm", "bump", "micro"])
+
     def test_process_with_publish_option(
         self,
         mock_execute: MagicMock,
@@ -761,150 +852,107 @@ class TestCrackerjackProcess:
                     cj.process(options)
                     mock_cj_execute.assert_any_call(["pre-commit", "autoupdate"])
 
-    def test_process_with_precommit_failure(
+    def test_update_precommit_ai_agent(
         self,
-        mock_execute: MagicMock,
         mock_console_print: MagicMock,
         tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
         options_factory: t.Callable[..., OptionsForTesting],
     ) -> None:
-        options = options_factory(no_config_updates=True)
-        with patch.object(ProjectManager, "run_pre_commit") as mock_run_precommit:
-            mock_run_precommit.side_effect = SystemExit(1)
-            with patch.object(Crackerjack, "_update_project"):
-                with pytest.raises(SystemExit) as excinfo:
-                    cj = Crackerjack(dry_run=True)
+        crackerjack_path = tmp_path / "crackerjack"
+        crackerjack_path.mkdir(exist_ok=True)
+        options = options_factory(update_precommit=True, ai_agent=True)
+        with patch.object(Crackerjack, "execute_command") as mock_cj_execute:
+            mock_cj_execute.return_value = MagicMock(returncode=0, stdout="Success")
+            cj = Crackerjack(pkg_path=crackerjack_path, dry_run=True)
+            with patch.object(cj, "_setup_package"):
+                with patch.object(cj, "_update_project"):
                     cj.process(options)
-                assert excinfo.value.code == 1
-                mock_run_precommit.assert_called_once()
+                    mock_cj_execute.assert_any_call(
+                        ["pre-commit", "autoupdate", "-c", ".pre-commit-config-ai.yaml"]
+                    )
 
-    def test_process_with_interactive_option(
+    def test_run_pre_commit_ai_agent(
         self,
-        mock_execute: MagicMock,
         mock_console_print: MagicMock,
         tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
         options_factory: t.Callable[..., OptionsForTesting],
     ) -> None:
-        options = options_factory(interactive=True, no_config_updates=True)
-        with patch.object(Crackerjack, "_update_project"):
-            cj = Crackerjack(dry_run=True)
-            cj.process(options)
+        mock_project = MagicMock()
+
+        options = options_factory(ai_agent=True)
+        mock_project.options = options
+
+        mock_project.console = MagicMock()
+
+        mock_project.execute_command.return_value = MagicMock(returncode=0)
 
-    def test_project_manager_run_interactive_success(
+        ProjectManager.run_pre_commit(mock_project)
+
+        mock_project.execute_command.assert_called_with(
+            ["pre-commit", "run", "--all-files", "-c", ".pre-commit-config-ai.yaml"]
+        )
+
+    def test_pre_commit_install_ai_agent(
         self,
-        mock_execute: MagicMock,
         mock_console_print: MagicMock,
         tmp_path: Path,
-        tmp_path_package: Path,
-        create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
     ) -> None:
-        with patch.object(ProjectManager, "execute_command") as mock_pm_execute:
-            mock_pm_execute.return_value = MagicMock(returncode=0, stdout="Success")
-            code_cleaner = CodeCleaner(console=Console())
-            config_manager = ConfigManager(
-                our_path=Path(),
-                pkg_path=Path(),
-                pkg_name="test",
-                console=Console(),
-                python_version="3.9",
-                dry_run=True,
-            )
-            pm = ProjectManager(
-                our_path=Path(),
-                pkg_path=Path(),
-                pkg_dir=Path(),
-                pkg_name="test",
-                console=Console(),
-                code_cleaner=code_cleaner,
-                config_manager=config_manager,
-                dry_run=True,
+        mock_project = MagicMock(spec=ProjectManager)
+
+        options = options_factory(ai_agent=True)
+        mock_project.options = options
+
+        mock_project.console = MagicMock()
+
+        mock_project.config_manager = MagicMock()
+
+        with patch.object(mock_project, "execute_command") as mock_execute:
+            mock_execute.return_value = MagicMock(
+                returncode=0,
+                stdout="package1\npackage2\n",
             )
-            pm.run_interactive("black")
-            mock_pm_execute.assert_called_once_with(
-                ["pre-commit", "run", "black", "--all-files"]
+
+            original_method = ProjectManager.update_pkg_configs
+
+            original_method(mock_project)
+
+            mock_execute.assert_any_call(
+                ["pre-commit", "install", "-c", ".pre-commit-config-ai.yaml"]
             )
 
-    def test_project_manager_run_interactive_failure_retry(
+    def test_process_with_precommit_failure(
         self,
         mock_execute: MagicMock,
         mock_console_print: MagicMock,
         tmp_path: Path,
         tmp_path_package: Path,
         create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
     ) -> None:
-        with patch.object(ProjectManager, "execute_command") as mock_pm_execute:
-            mock_pm_execute.side_effect = [
-                MagicMock(returncode=1, stdout="", stderr="Failed"),
-                MagicMock(returncode=0, stdout="Success"),
-            ]
-            with patch("builtins.input", return_value="y"):
-                code_cleaner = CodeCleaner(console=Console())
-                config_manager = ConfigManager(
-                    our_path=Path(),
-                    pkg_path=Path(),
-                    pkg_name="test",
-                    console=Console(),
-                    python_version="3.9",
-                    dry_run=True,
-                )
-                pm = ProjectManager(
-                    our_path=Path(),
-                    pkg_path=Path(),
-                    pkg_dir=Path(),
-                    pkg_name="test",
-                    console=Console(),
-                    code_cleaner=code_cleaner,
-                    config_manager=config_manager,
-                    dry_run=True,
-                )
-                pm.run_interactive("black")
-                assert mock_pm_execute.call_count == 2
-                mock_pm_execute.assert_called_with(
-                    ["pre-commit", "run", "black", "--all-files"]
-                )
+        options = options_factory(no_config_updates=True)
+        with patch.object(ProjectManager, "run_pre_commit") as mock_run_precommit:
+            mock_run_precommit.side_effect = SystemExit(1)
+            with patch.object(Crackerjack, "_update_project"):
+                with pytest.raises(SystemExit) as excinfo:
+                    cj = Crackerjack(dry_run=True)
+                    cj.process(options)
+                assert excinfo.value.code == 1
+                mock_run_precommit.assert_called_once()
 
-    def test_project_manager_run_interactive_failure_exit(
+    def test_process_with_interactive_option(
         self,
         mock_execute: MagicMock,
         mock_console_print: MagicMock,
         tmp_path: Path,
         tmp_path_package: Path,
         create_package_dir: None,
+        options_factory: t.Callable[..., OptionsForTesting],
     ) -> None:
-        with patch.object(ProjectManager, "execute_command") as mock_pm_execute:
-            mock_pm_execute.return_value = MagicMock(
-                returncode=1, stdout="", stderr="Failed"
-            )
-            with patch("builtins.input", return_value="n"):
-                code_cleaner = CodeCleaner(console=Console())
-                config_manager = ConfigManager(
-                    our_path=Path(),
-                    pkg_path=Path(),
-                    pkg_name="test",
-                    console=Console(),
-                    python_version="3.9",
-                    dry_run=True,
-                )
-                pm = ProjectManager(
-                    our_path=Path(),
-                    pkg_path=Path(),
-                    pkg_dir=Path(),
-                    pkg_name="test",
-                    console=Console(),
-                    code_cleaner=code_cleaner,
-                    config_manager=config_manager,
-                    dry_run=True,
-                )
-                with pytest.raises(SystemExit) as excinfo:
-                    pm.run_interactive("black")
-                assert excinfo.value.code == 1
-                mock_pm_execute.assert_called_once_with(
-                    ["pre-commit", "run", "black", "--all-files"]
-                )
+        options = options_factory(interactive=True, no_config_updates=True)
+        with patch.object(Crackerjack, "_update_project"):
+            cj = Crackerjack(dry_run=True)
+            cj.process(options)
 
     def test_config_manager_swap_package_name(
         self, mock_execute: MagicMock, mock_console_print: MagicMock, tmp_path: Path

{crackerjack-0.21.0 → crackerjack-0.21.2}/tests/test_crackerjack_runner.py

@@ -88,8 +88,9 @@ def test_process_with_all_option(
     crackerjack, mocks = mock_crackerjack
     options = MockOptions(all="minor")
     with patch.object(Crackerjack, "_run_tests"):
-        with patch("builtins.input", return_value="Test commit message"):
-            crackerjack.process(options)
+        with patch("rich.prompt.Confirm.ask", return_value=True):
+            with patch("builtins.input", return_value="Test commit message"):
+                crackerjack.process(options)
     assert options.clean is True
     assert options.test is True
     assert options.publish == "minor"