feat: do not run quality checks when no files have changed

Author: joshuanapoli

README.md

@@ -14,10 +14,10 @@ Each time a file is edited:
 When Claude is ready to stop:
 - Reformat edited files with `ruff format`
 - Repair lints of edited files with `ruff check --fix`
-- Type-check edited files with `mypy`
-- Run the tests with `pytest`
+- Type-check the project with `mypy` (only if files were edited)
+- Run the tests with `pytest` (only if files were edited)
 
-Note: We defer `ruff format` and `ruff check` until Claude stops to avoid changing files while Claude is working. Changing files during editing would spoil Claude's edits and force it to reread files.
+Note: We defer all quality checks until Claude stops to avoid changing files while Claude is working. Changing files during editing would spoil Claude's edits and force it to reread files. Quality checks only run when at least one Python file has been edited during the session.
 ## Installation
 
 ```bash

src/python_claude/hooks/edited_hook.py

@@ -50,8 +50,10 @@ def run(self) -> int:
         if not file_path or not self.is_python_file(file_path):
             return 0
 
-        # Track for both ruff check and ruff format
+        # Track for all quality checks
         self._track_file(self.check_track_file, file_path)
         self._track_file(self.format_track_file, file_path)
+        self._track_file(self.mypy_track_file, file_path)
+        self._track_file(self.pytest_track_file, file_path)
 
         return 0

src/python_claude/hooks/mypy_hook.py

@@ -25,7 +25,8 @@ def run(self) -> int:
         """Run mypy on the edited file or entire project if enabled.
 
         If file_path is provided and is a Python file, run mypy on that file.
-        If no file_path is provided (e.g., Stop hook), run mypy on entire project.
+        If no file_path is provided (e.g., Stop hook), run mypy on entire project
+        only if files were edited.
         """
         state = QualityCheckState(self.project_dir)
         if not state.is_enabled("mypy"):
@@ -41,7 +42,11 @@ def run(self) -> int:
                 return 0
             mypy_target = file_path
         else:
-            # No file path (Stop hook) - check entire project
+            # No file path (Stop hook) - check if any Python files were edited
+            if not self.track_file.exists() or self.track_file.stat().st_size == 0:
+                self.log("No edited Python files")
+                return 0
+            # Check entire project
             mypy_target = "."
 
         self.log(mypy_target)
@@ -56,6 +61,10 @@ def run(self) -> int:
         exit_code = result.returncode
         self.log(f"exit {exit_code}")
 
+        # Clean up tracking file on success (only for Stop hook)
+        if exit_code == 0 and not file_path:
+            self.track_file.unlink(missing_ok=True)
+
         # Map mypy exit code 1 (type errors) to exit code 2 for Claude Code correction
         if exit_code == 1:
             return 2

src/python_claude/hooks/pytest_hook.py

@@ -22,12 +22,19 @@ def track_file(self) -> Path:
         return self.log_dir / "pytest-files.txt"
 
     def run(self) -> int:
-        """Run pytest if enabled."""
+        """Run pytest if enabled and files were edited."""
         state = QualityCheckState(self.project_dir)
         if not state.is_enabled("pytest"):
             self.log("Skipped (disabled)")
             return 0
 
+        # Check if any Python files were edited
+        if not self.track_file.exists() or self.track_file.stat().st_size == 0:
+            self.log("No edited Python files")
+            return 0
+
+        self.log("Running pytest")
+
         result = subprocess.run(
             ["poetry", "run", "pytest"],
             cwd=self.project_dir,
@@ -40,4 +47,9 @@ def run(self) -> int:
         if exit_code == 1:
             exit_code = 2
         self.log(f"exit {exit_code}")
+
+        # Clean up tracking file on success
+        if exit_code == 0:
+            self.track_file.unlink(missing_ok=True)
+
         return exit_code

tests/test_edited_hook.py

@@ -19,11 +19,15 @@ def test_tracks_python_file(self, tmp_path: Path) -> None:
             hook = EditedHook(hook_input)
             exit_code = hook.run()
             assert exit_code == 0
-            # Check both tracking files
+            # Check all tracking files
             assert hook.check_track_file.exists()
             assert "/test/file.py" in hook.check_track_file.read_text()
             assert hook.format_track_file.exists()
             assert "/test/file.py" in hook.format_track_file.read_text()
+            assert hook.mypy_track_file.exists()
+            assert "/test/file.py" in hook.mypy_track_file.read_text()
+            assert hook.pytest_track_file.exists()
+            assert "/test/file.py" in hook.pytest_track_file.read_text()
 
     def test_ignores_non_python_file(self, tmp_path: Path) -> None:
         hook_input = HookInput(
@@ -37,6 +41,8 @@ def test_ignores_non_python_file(self, tmp_path: Path) -> None:
             assert exit_code == 0
             assert not hook.check_track_file.exists()
             assert not hook.format_track_file.exists()
+            assert not hook.mypy_track_file.exists()
+            assert not hook.pytest_track_file.exists()
 
     def test_does_not_duplicate_files(self, tmp_path: Path) -> None:
         hook_input = HookInput(
@@ -49,8 +55,12 @@ def test_does_not_duplicate_files(self, tmp_path: Path) -> None:
             hook1.run()
             hook2 = EditedHook(hook_input)
             hook2.run()
-            # Check both tracking files don't have duplicates
+            # Check all tracking files don't have duplicates
             check_content = hook2.check_track_file.read_text()
             assert check_content.count("/test/file.py") == 1
             format_content = hook2.format_track_file.read_text()
             assert format_content.count("/test/file.py") == 1
+            mypy_content = hook2.mypy_track_file.read_text()
+            assert mypy_content.count("/test/file.py") == 1
+            pytest_content = hook2.pytest_track_file.read_text()
+            assert pytest_content.count("/test/file.py") == 1

tests/test_mypy_hook.py

@@ -87,6 +87,10 @@ def test_stop_hook_no_file_path_success(self, tmp_path: Path) -> None:
         )
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = MypyHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 0
             with patch("subprocess.run", return_value=mock_result) as mock_run:
@@ -96,6 +100,8 @@ def test_stop_hook_no_file_path_success(self, tmp_path: Path) -> None:
                 # Verify it ran mypy on current directory
                 call_args = mock_run.call_args
                 assert call_args[0][0] == ["poetry", "run", "mypy", "."]
+                # Verify tracking file was cleaned up on success
+                assert not hook.track_file.exists()
 
     def test_stop_hook_type_errors(self, tmp_path: Path) -> None:
         """Test Stop hook with type errors (exit 1) transforms to exit code 2."""
@@ -110,12 +116,36 @@ def test_stop_hook_type_errors(self, tmp_path: Path) -> None:
         )
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = MypyHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 1
             with patch("subprocess.run", return_value=mock_result):
                 exit_code = hook.run()
                 assert exit_code == 2
 
+    def test_stop_hook_no_files_edited(self, tmp_path: Path) -> None:
+        """Test Stop hook is skipped when no files were edited."""
+        hook_input = HookInput(
+            session_id="abc123",
+            tool_input={},
+            raw={
+                "session_id": "abc123",
+                "hook_event_name": "Stop",
+                "stop_hook_active": True,
+            },
+        )
+        with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
+            hook = MypyHook(hook_input)
+            # Don't create tracking file
+            with patch("subprocess.run") as mock_run:
+                exit_code = hook.run()
+                assert exit_code == 0
+                # Verify subprocess was not called
+                mock_run.assert_not_called()
+
     def test_empty_file_path_runs_full_check(self, tmp_path: Path) -> None:
         """Test empty string file_path is treated as Stop hook."""
         hook_input = HookInput(
@@ -125,6 +155,10 @@ def test_empty_file_path_runs_full_check(self, tmp_path: Path) -> None:
         )
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = MypyHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 0
             with patch("subprocess.run", return_value=mock_result) as mock_run:

tests/test_pytest_hook.py

@@ -15,17 +15,27 @@ def test_pytest_success(self, tmp_path: Path) -> None:
         hook_input = HookInput(session_id=None, tool_input={}, raw={})
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = PytestHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 0
             with patch("subprocess.run", return_value=mock_result):
                 exit_code = hook.run()
                 assert exit_code == 0
+                # Verify tracking file was cleaned up on success
+                assert not hook.track_file.exists()
 
     def test_pytest_test_failures(self, tmp_path: Path) -> None:
         """Test that exit code 1 (test failures) is transformed to exit code 2."""
         hook_input = HookInput(session_id=None, tool_input={}, raw={})
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = PytestHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 1
             with patch("subprocess.run", return_value=mock_result):
@@ -37,6 +47,10 @@ def test_pytest_other_error(self, tmp_path: Path) -> None:
         hook_input = HookInput(session_id=None, tool_input={}, raw={})
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = PytestHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 3
             with patch("subprocess.run", return_value=mock_result):
@@ -48,12 +62,28 @@ def test_pytest_no_tests_collected(self, tmp_path: Path) -> None:
         hook_input = HookInput(session_id=None, tool_input={}, raw={})
         with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
             hook = PytestHook(hook_input)
+            # Create tracking file with edited files
+            hook.track_file.parent.mkdir(parents=True, exist_ok=True)
+            hook.track_file.write_text("/path/to/file.py\n")
+
             mock_result = MagicMock()
             mock_result.returncode = 5
             with patch("subprocess.run", return_value=mock_result):
                 exit_code = hook.run()
                 assert exit_code == 5
 
+    def test_pytest_no_files_edited(self, tmp_path: Path) -> None:
+        """Test that pytest is skipped when no files were edited."""
+        hook_input = HookInput(session_id=None, tool_input={}, raw={})
+        with patch.dict(os.environ, {"CLAUDE_PROJECT_DIR": str(tmp_path)}):
+            hook = PytestHook(hook_input)
+            # Don't create tracking file
+            with patch("subprocess.run") as mock_run:
+                exit_code = hook.run()
+                assert exit_code == 0
+                # Verify subprocess was not called
+                mock_run.assert_not_called()
+
     def test_pytest_skipped_when_disabled(self, tmp_path: Path) -> None:
         """Test that pytest is skipped when disabled in state."""
         hook_input = HookInput(session_id=None, tool_input={}, raw={})