style: apply ruff formatting and fix unused imports

- Format 10 files with ruff format
- Remove unused imports (tempfile, Any) from test_hook_integration.py
- Sort import blocks in test_hook_integration.py

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: zircote

src/git_notes_memory/hooks/config_loader.py

@@ -226,9 +226,7 @@ def load_hook_config(env: dict[str, str] | None = None) -> HookConfig:
 
     # SessionStart settings
     if "HOOK_SESSION_START_ENABLED" in env:
-        kwargs["session_start_enabled"] = _parse_bool(
-            env["HOOK_SESSION_START_ENABLED"]
-        )
+        kwargs["session_start_enabled"] = _parse_bool(env["HOOK_SESSION_START_ENABLED"])
     if "HOOK_SESSION_START_BUDGET_MODE" in env:
         with contextlib.suppress(ValueError):
             kwargs["session_start_budget_mode"] = _parse_budget_mode(
@@ -268,9 +266,7 @@ def load_hook_config(env: dict[str, str] | None = None) -> HookConfig:
 
     # UserPromptSubmit hook settings
     if "HOOK_USER_PROMPT_ENABLED" in env:
-        kwargs["user_prompt_enabled"] = _parse_bool(
-            env["HOOK_USER_PROMPT_ENABLED"]
-        )
+        kwargs["user_prompt_enabled"] = _parse_bool(env["HOOK_USER_PROMPT_ENABLED"])
 
     # Stop hook settings
     if "HOOK_STOP_ENABLED" in env:

src/git_notes_memory/hooks/project_detector.py

@@ -133,7 +133,9 @@ def _get_git_repo_name(git_root: Path) -> str | None:
         # Match patterns like:
         #   url = git@github.com:user/repo.git
         #   url = https://github.com/user/repo.git
-        match = re.search(r'url\s*=\s*.*[/:]([^/]+?)(?:\.git)?\s*$', content, re.MULTILINE)
+        match = re.search(
+            r"url\s*=\s*.*[/:]([^/]+?)(?:\.git)?\s*$", content, re.MULTILINE
+        )
         if match:
             return match.group(1)
     except OSError:
@@ -278,7 +280,7 @@ def _extract_spec_from_claude_md(claude_md_path: Path) -> str | None:
         patterns = [
             r'(?:spec_id|project_id):\s*["\']?(SPEC-\d{4}-\d{2}-\d{2}-\d+)["\']?',
             r'Active\s+Spec:\s*["\']?(SPEC-\d{4}-\d{2}-\d{2}-\d+)["\']?',
-            r'\b(SPEC-\d{4}-\d{2}-\d{2}-\d+)\b',  # Any SPEC-... pattern
+            r"\b(SPEC-\d{4}-\d{2}-\d{2}-\d+)\b",  # Any SPEC-... pattern
         ]
         for pattern in patterns:
             match = re.search(pattern, content, re.IGNORECASE)

src/git_notes_memory/hooks/session_analyzer.py

@@ -280,9 +280,7 @@ def analyze_content(
         # Filter by novelty
         if check_novelty and filtered:
             checker = self._get_novelty_checker()
-            filtered = [
-                s for s in filtered if checker.check_signal_novelty(s).is_novel
-            ]
+            filtered = [s for s in filtered if checker.check_signal_novelty(s).is_novel]
 
         # Sort and limit
         filtered.sort(key=lambda s: s.confidence, reverse=True)

src/git_notes_memory/hooks/signal_detector.py

@@ -47,7 +47,10 @@
     ],
     SignalType.LEARNING: [
         # Strong learning signals
-        (r"(?i)\b(I|we)\s+(learned|realized|discovered|found out)\s+(that|about)?\b", 0.90),
+        (
+            r"(?i)\b(I|we)\s+(learned|realized|discovered|found out)\s+(that|about)?\b",
+            0.90,
+        ),
         (r"(?i)\bTIL\b", 0.95),  # Very strong explicit signal
         (r"(?i)\bturns out\b", 0.85),
         (r"(?i)\bkey (insight|takeaway|learning)[:\s]", 0.92),
@@ -136,7 +139,9 @@ class SignalDetector:
     """
 
     # Class-level compiled patterns cache
-    _compiled_patterns: ClassVar[dict[SignalType, list[tuple[re.Pattern[str], float]]]] = {}
+    _compiled_patterns: ClassVar[
+        dict[SignalType, list[tuple[re.Pattern[str], float]]]
+    ] = {}
 
     def __init__(
         self,
@@ -241,7 +246,9 @@ def detect(self, text: str) -> list[CaptureSignal]:
         # Sort by position
         signals.sort(key=lambda s: s.position)
 
-        logger.debug("Detected %d signals in text of length %d", len(signals), len(text))
+        logger.debug(
+            "Detected %d signals in text of length %d", len(signals), len(text)
+        )
         return signals
 
     def _extract_context(self, text: str, start: int, end: int) -> str:

src/git_notes_memory/hooks/user_prompt_handler.py

@@ -296,7 +296,9 @@ def main() -> None:
     try:
         # Read and validate input
         input_data = _read_input()
-        logger.debug("Received input with prompt: %s...", input_data.get("prompt", "")[:50])
+        logger.debug(
+            "Received input with prompt: %s...", input_data.get("prompt", "")[:50]
+        )
 
         if not _validate_input(input_data):
             logger.warning("Invalid hook input - missing prompt field")
@@ -320,7 +322,9 @@ def main() -> None:
         decider = CaptureDecider(config=config)
         decision = decider.decide(signals)
 
-        logger.debug("Capture decision: %s - %s", decision.action.value, decision.reason)
+        logger.debug(
+            "Capture decision: %s - %s", decision.action.value, decision.reason
+        )
 
         # Handle the decision
         captured: list[dict[str, Any]] = []

tests/test_hook_handlers.py

@@ -79,7 +79,10 @@ def temp_transcript(tmp_path: Path) -> Path:
                 "messages": [
                     {"role": "user", "content": "I decided to use PostgreSQL"},
                     {"role": "assistant", "content": "Good choice!"},
-                    {"role": "user", "content": "I learned that indexes improve performance"},
+                    {
+                        "role": "user",
+                        "content": "I learned that indexes improve performance",
+                    },
                 ]
             }
         )
@@ -160,7 +163,10 @@ def test_write_output_format(self) -> None:
         output = json.loads(captured.getvalue())
         assert "hookSpecificOutput" in output
         assert output["hookSpecificOutput"]["hookEventName"] == "SessionStart"
-        assert output["hookSpecificOutput"]["additionalContext"] == "<context>test</context>"
+        assert (
+            output["hookSpecificOutput"]["additionalContext"]
+            == "<context>test</context>"
+        )
 
     def test_setup_logging_debug(self) -> None:
         """Test debug logging setup configures correctly."""
@@ -327,7 +333,9 @@ def test_write_output_auto_action(self) -> None:
                 confidence=0.98,
             )
         ]
-        captured_memories = [{"success": True, "memory_id": "abc123", "summary": "Test"}]
+        captured_memories = [
+            {"success": True, "memory_id": "abc123", "summary": "Test"}
+        ]
 
         out = io.StringIO()
         with patch.object(sys, "stdout", out):
@@ -522,9 +530,7 @@ def test_session_start_wrapper_import_error(self) -> None:
         import importlib.util
         from pathlib import Path as P
 
-        wrapper_path = (
-            P(__file__).parent.parent / "hooks" / "session_start.py"
-        )
+        wrapper_path = P(__file__).parent.parent / "hooks" / "session_start.py"
         if not wrapper_path.exists():
             pytest.skip("Wrapper script not found")
 
@@ -549,9 +555,7 @@ def test_user_prompt_wrapper_import_error(self) -> None:
         import importlib.util
         from pathlib import Path as P
 
-        wrapper_path = (
-            P(__file__).parent.parent / "hooks" / "user_prompt.py"
-        )
+        wrapper_path = P(__file__).parent.parent / "hooks" / "user_prompt.py"
         if not wrapper_path.exists():
             pytest.skip("Wrapper script not found")
 
@@ -580,9 +584,7 @@ def test_stop_wrapper_import_error(self) -> None:
         import importlib.util
         from pathlib import Path as P
 
-        wrapper_path = (
-            P(__file__).parent.parent / "hooks" / "stop.py"
-        )
+        wrapper_path = P(__file__).parent.parent / "hooks" / "stop.py"
         if not wrapper_path.exists():
             pytest.skip("Wrapper script not found")
 
@@ -673,9 +675,7 @@ def test_session_start_respects_disabled_hook(
         config = load_hook_config()
         assert config.enabled is False
 
-    def test_user_prompt_respects_disabled_hook(
-        self, hook_env_disabled: None
-    ) -> None:
+    def test_user_prompt_respects_disabled_hook(self, hook_env_disabled: None) -> None:
         """Test UserPromptSubmit respects HOOK_ENABLED=false."""
         from git_notes_memory.hooks.config_loader import load_hook_config
 

tests/test_hook_integration.py

@@ -16,9 +16,8 @@
 import json
 import os
 import sys
-import tempfile
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -40,14 +39,12 @@ def temp_git_repo(tmp_path: Path) -> Generator[Path, None, None]:
     (git_dir / "HEAD").write_text("ref: refs/heads/main")
     # Include origin URL so git_repo name can be detected
     (git_dir / "config").write_text(
-        '[core]\n\trepositoryformatversion = 0\n'
+        "[core]\n\trepositoryformatversion = 0\n"
         '[remote "origin"]\n\turl = https://github.com/test-user/test-project.git\n'
     )
 
     # Create a basic project structure
-    (tmp_path / "pyproject.toml").write_text(
-        '[project]\nname = "test-project"\n'
-    )
+    (tmp_path / "pyproject.toml").write_text('[project]\nname = "test-project"\n')
     (tmp_path / "src").mkdir()
 
     yield tmp_path
@@ -179,7 +176,9 @@ def test_session_start_json_output_format(
         """Test SessionStart hook produces valid JSON output."""
         from git_notes_memory.hooks.session_start_handler import _write_output
 
-        context = "<memory_context project='test'><summary>Test</summary></memory_context>"
+        context = (
+            "<memory_context project='test'><summary>Test</summary></memory_context>"
+        )
 
         captured = io.StringIO()
         with patch.object(sys, "stdout", captured):
@@ -319,7 +318,11 @@ def test_low_confidence_signals_skipped(self, hook_env_enabled: None) -> None:
         """Test that low-confidence signals result in SKIP action."""
         from git_notes_memory.hooks.capture_decider import CaptureDecider
         from git_notes_memory.hooks.config_loader import load_hook_config
-        from git_notes_memory.hooks.models import CaptureAction, CaptureSignal, SignalType
+        from git_notes_memory.hooks.models import (
+            CaptureAction,
+            CaptureSignal,
+            SignalType,
+        )
 
         # Create a low-confidence signal
         signals = [
@@ -448,12 +451,12 @@ def test_session_flow_start_to_stop(
         self, temp_git_repo: Path, hook_env_enabled: None
     ) -> None:
         """Test complete session flow from start to stop."""
+        from git_notes_memory.hooks.capture_decider import CaptureDecider
         from git_notes_memory.hooks.config_loader import load_hook_config
         from git_notes_memory.hooks.context_builder import ContextBuilder
         from git_notes_memory.hooks.models import CaptureAction
         from git_notes_memory.hooks.project_detector import detect_project
         from git_notes_memory.hooks.signal_detector import SignalDetector
-        from git_notes_memory.hooks.capture_decider import CaptureDecider
 
         # 1. Session Start - detect project and build context
         project_info = detect_project(str(temp_git_repo))
@@ -556,14 +559,14 @@ def test_stop_handles_invalid_transcript(
         result = _analyze_session(str(invalid))
         assert result == []
 
-    def test_all_hooks_output_continue_on_error(
-        self, hook_env_enabled: None
-    ) -> None:
+    def test_all_hooks_output_continue_on_error(self, hook_env_enabled: None) -> None:
         """Test that all hooks output continue:true even on errors."""
         # This verifies the non-blocking error handling pattern
 
         # SessionStart - outputs empty on error (no hookSpecificOutput)
-        from git_notes_memory.hooks.session_start_handler import _write_output as ss_write
+        from git_notes_memory.hooks.session_start_handler import (
+            _write_output as ss_write,
+        )
 
         captured = io.StringIO()
         with patch.object(sys, "stdout", captured):
@@ -572,8 +575,8 @@ def test_all_hooks_output_continue_on_error(
         # SessionStart doesn't have continue field but hookSpecificOutput
 
         # UserPromptSubmit - outputs continue:true
-        from git_notes_memory.hooks.user_prompt_handler import _write_output as up_write
         from git_notes_memory.hooks.models import CaptureAction
+        from git_notes_memory.hooks.user_prompt_handler import _write_output as up_write
 
         captured = io.StringIO()
         with patch.object(sys, "stdout", captured):

tests/test_hooks.py

@@ -357,7 +357,9 @@ def test_signal_context_extraction(self, signal_detector: SignalDetector) -> Non
         assert len(signals) >= 1
         # Context should include surrounding text
         decision_signal = next(s for s in signals if s.type == SignalType.DECISION)
-        assert "Redis" in decision_signal.context or "caching" in decision_signal.context
+        assert (
+            "Redis" in decision_signal.context or "caching" in decision_signal.context
+        )
 
     def test_confidence_scoring(self, signal_detector: SignalDetector) -> None:
         """Test that confidence scores are reasonable."""

tests/test_hooks_integration.py

@@ -102,11 +102,24 @@ def transcript_file(tmp_path: Path) -> Path:
     transcript = tmp_path / "transcript.jsonl"
     # Write JSONL format (one JSON object per line)
     lines = [
-        json.dumps({"role": "user", "content": "I decided to use PostgreSQL for the database"}),
-        json.dumps({"role": "assistant", "content": "Good choice for relational data!"}),
-        json.dumps({"role": "user", "content": "I learned that indexes improve query performance"}),
-        json.dumps({"role": "assistant", "content": "Yes, especially for large tables."}),
-        json.dumps({"role": "user", "content": "The API rate limit is blocking progress"}),
+        json.dumps(
+            {"role": "user", "content": "I decided to use PostgreSQL for the database"}
+        ),
+        json.dumps(
+            {"role": "assistant", "content": "Good choice for relational data!"}
+        ),
+        json.dumps(
+            {
+                "role": "user",
+                "content": "I learned that indexes improve query performance",
+            }
+        ),
+        json.dumps(
+            {"role": "assistant", "content": "Yes, especially for large tables."}
+        ),
+        json.dumps(
+            {"role": "user", "content": "The API rate limit is blocking progress"}
+        ),
     ]
     transcript.write_text("\n".join(lines))
     return transcript
@@ -151,9 +164,7 @@ def test_full_flow_with_git_repo(
         # requires proper database setup for full end-to-end testing.
         # Here we validate the project detection flow works correctly.
 
-    def test_full_flow_with_spec_id(
-        self, spec_project: Path, hook_env: None
-    ) -> None:
+    def test_full_flow_with_spec_id(self, spec_project: Path, hook_env: None) -> None:
         """Test SessionStart flow detects active spec."""
         from git_notes_memory.hooks.project_detector import detect_project
 
@@ -240,9 +251,7 @@ def test_blocker_signal_detection(self, hook_env: None) -> None:
         from git_notes_memory.hooks.signal_detector import SignalDetector
 
         detector = SignalDetector()
-        signals = detector.detect(
-            "We are blocked by the external API being down"
-        )
+        signals = detector.detect("We are blocked by the external API being down")
 
         assert len(signals) >= 1
         assert any(s.type.value == "blocker" for s in signals)
@@ -253,7 +262,9 @@ def test_explicit_remember_signal(self, hook_env: None) -> None:
 
         detector = SignalDetector()
         # Use a stronger trigger that matches pattern detection
-        signals = detector.detect("/remember: always use prepared statements for security")
+        signals = detector.detect(
+            "/remember: always use prepared statements for security"
+        )
 
         # The explicit signal might require specific patterns
         # If no explicit signal, at least verify no crash
@@ -416,9 +427,7 @@ def test_config_consistency_across_handlers(self, hook_env: None) -> None:
         assert config1.user_prompt_enabled == config2.user_prompt_enabled
         assert config1.stop_enabled == config2.stop_enabled
 
-    def test_signal_detector_and_analyzer_compatibility(
-        self, hook_env: None
-    ) -> None:
+    def test_signal_detector_and_analyzer_compatibility(self, hook_env: None) -> None:
         """Test SignalDetector and SessionAnalyzer produce compatible signals."""
         from git_notes_memory.hooks.models import CaptureSignal
         from git_notes_memory.hooks.signal_detector import SignalDetector

tests/test_hooks_performance.py

@@ -309,7 +309,9 @@ def test_transcript_parsing_speed(self, tmp_path: Path, hook_env: None) -> None:
             if i % 2 == 0:
                 lines.append(json.dumps({"role": "user", "content": f"Message {i}"}))
             else:
-                lines.append(json.dumps({"role": "assistant", "content": f"Response {i}"}))
+                lines.append(
+                    json.dumps({"role": "assistant", "content": f"Response {i}"})
+                )
         transcript.write_text("\n".join(lines))
 
         analyzer = SessionAnalyzer()