chore: ruff format

Author: kenryu42

scripts/export_plan.py

@@ -13,7 +13,9 @@
 from pathlib import Path
 
 
-def find_slug_in_transcript(transcript_path: Path, *, retries: int = 5, delay: float = 0.05) -> str | None:
+def find_slug_in_transcript(
+    transcript_path: Path, *, retries: int = 5, delay: float = 0.05
+) -> str | None:
     """Scan transcript JSONL for the first object containing a 'slug' field.
 
     Retries to handle concurrent writes that may temporarily produce malformed lines.

scripts/export_project_plans.py

@@ -68,7 +68,9 @@ def main() -> int:
         dest_file = Path.cwd() / f"plan-{slug}.md"
 
         if not source_file.exists():
-            print(f"Plan file not found for slug '{slug}': {source_file}", file=sys.stderr)
+            print(
+                f"Plan file not found for slug '{slug}': {source_file}", file=sys.stderr
+            )
             continue
 
         try:

scripts/export_project_plans_with_timestamp.py

@@ -60,7 +60,9 @@ def main() -> int:
         source_file = plans_dir / f"{slug}.md"
 
         if not source_file.exists():
-            print(f"Plan file not found for slug '{slug}': {source_file}", file=sys.stderr)
+            print(
+                f"Plan file not found for slug '{slug}': {source_file}", file=sys.stderr
+            )
             continue
 
         timestamp = get_file_timestamp(source_file)

scripts/session_start.py

@@ -46,7 +46,9 @@ def main() -> int:
         with open(env_file, "a", encoding="utf-8") as f:
             try:
                 fcntl.flock(f.fileno(), fcntl.LOCK_EX)
-                f.write(f'export TRANSCRIPT_PATH="{os.path.dirname(transcript_path)}"\n')
+                f.write(
+                    f'export TRANSCRIPT_PATH="{os.path.dirname(transcript_path)}"\n'
+                )
             finally:
                 try:
                     fcntl.flock(f.fileno(), fcntl.LOCK_UN)

tests/run_tests.py

@@ -4,5 +4,5 @@
 import sys
 from runner import run_tests
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(run_tests())

tests/runner.py

@@ -9,17 +9,19 @@
     from unittest.runner import _WritelnDecorator
 
 # ANSI color codes
-GREEN = '\033[92m'
-RED = '\033[91m'
-YELLOW = '\033[93m'
-BOLD = '\033[1m'
-RESET = '\033[0m'
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
 
 
 class ColorTextTestResult(unittest.TextTestResult):
     """Custom test result class with colorized output and output buffering."""
 
-    def __init__(self, stream: "_WritelnDecorator", descriptions: bool, verbosity: int) -> None:
+    def __init__(
+        self, stream: "_WritelnDecorator", descriptions: bool, verbosity: int
+    ) -> None:
         super().__init__(stream, descriptions, verbosity)
         self.buffer = True  # Enable output buffering
         self.current_class = None
@@ -33,85 +35,96 @@ def startTest(self, test):
         test_class = test.__class__.__name__
         if test_class != self.current_class:
             self.current_class = test_class
-            self.stream.write('\n')
-            self.stream.write('═' * 43)
-            self.stream.write('\n')
-            self.stream.write(f'{BOLD}{test_class}{RESET}\n')
-            self.stream.write('─' * 43)
-            self.stream.write('\n')
+            self.stream.write("\n")
+            self.stream.write("═" * 43)
+            self.stream.write("\n")
+            self.stream.write(f"{BOLD}{test_class}{RESET}\n")
+            self.stream.write("─" * 43)
+            self.stream.write("\n")
             self.stream.flush()
 
     def addSuccess(self, test):
         """Called when a test passes."""
         super().addSuccess(test)
         if self.showAll:
             test_method = test._testMethodName
-            self.stream.write(f'{GREEN}✓{RESET} {test_method}\n')
+            self.stream.write(f"{GREEN}✓{RESET} {test_method}\n")
             self.stream.flush()
         elif self.dots:
-            self.stream.write(f'{GREEN}.{RESET}')
+            self.stream.write(f"{GREEN}.{RESET}")
             self.stream.flush()
 
     def addError(self, test, err):
         """Called when a test has an error."""
         super().addError(test, err)
         if self.showAll:
             test_method = test._testMethodName
-            self.stream.write(f'{RED}{BOLD}E{RESET} {test_method}\n')
+            self.stream.write(f"{RED}{BOLD}E{RESET} {test_method}\n")
             self.stream.flush()
         elif self.dots:
-            self.stream.write(f'{RED}{BOLD}E{RESET}')
+            self.stream.write(f"{RED}{BOLD}E{RESET}")
             self.stream.flush()
 
     def addFailure(self, test, err):
         """Called when a test fails."""
         super().addFailure(test, err)
         if self.showAll:
             test_method = test._testMethodName
-            self.stream.write(f'{RED}F{RESET} {test_method}\n')
+            self.stream.write(f"{RED}F{RESET} {test_method}\n")
             self.stream.flush()
         elif self.dots:
-            self.stream.write(f'{RED}F{RESET}')
+            self.stream.write(f"{RED}F{RESET}")
             self.stream.flush()
 
     def addSkip(self, test, reason):
         """Called when a test is skipped."""
         super().addSkip(test, reason)
         if self.showAll:
             test_method = test._testMethodName
-            self.stream.write(f'{YELLOW}s{RESET} {test_method} (skipped: {reason})\n')
+            self.stream.write(f"{YELLOW}s{RESET} {test_method} (skipped: {reason})\n")
             self.stream.flush()
         elif self.dots:
-            self.stream.write(f'{YELLOW}s{RESET}')
+            self.stream.write(f"{YELLOW}s{RESET}")
             self.stream.flush()
 
     def printErrors(self):
         """Print errors and failures with captured output."""
         if self.dots or self.showAll:
-            self.stream.write('\n')
-        self.printErrorList('ERROR', self.errors)
-        self.printErrorList('FAIL', self.failures)
+            self.stream.write("\n")
+        self.printErrorList("ERROR", self.errors)
+        self.printErrorList("FAIL", self.failures)
 
     def printErrorList(self, flavour, errors):
         """Print formatted error list with captured output."""
         for test, err in errors:
-            self.stream.write('\n')
-            self.stream.write('═' * 43)
-            self.stream.write('\n')
-            self.stream.write(f'{RED}{BOLD}{flavour}: {self.getDescription(test)}{RESET}\n')
-            self.stream.write('─' * 43)
-            self.stream.write('\n')
-            self.stream.write(f'{err}\n')
+            self.stream.write("\n")
+            self.stream.write("═" * 43)
+            self.stream.write("\n")
+            self.stream.write(
+                f"{RED}{BOLD}{flavour}: {self.getDescription(test)}{RESET}\n"
+            )
+            self.stream.write("─" * 43)
+            self.stream.write("\n")
+            self.stream.write(f"{err}\n")
 
 
 class ColorTestRunner(unittest.TextTestRunner):
     """Custom test runner that uses ColorTextTestResult."""
 
     resultclass = ColorTextTestResult  # type: ignore[assignment]
 
-    def __init__(self, stream=None, descriptions=True, verbosity=2,
-                 failfast=False, buffer=True, resultclass=None, warnings=None,
-                 *, tb_locals=False):
+    def __init__(
+        self,
+        stream=None,
+        descriptions=True,
+        verbosity=2,
+        failfast=False,
+        buffer=True,
+        resultclass=None,
+        warnings=None,
+        *,
+        tb_locals=False,
+    ):
         super().__init__(
             stream=stream,
             descriptions=descriptions,
@@ -120,7 +133,7 @@ def __init__(self, stream=None, descriptions=True, verbosity=2,
             buffer=buffer,
             resultclass=resultclass or ColorTextTestResult,  # type: ignore[arg-type]
             warnings=warnings,
-            tb_locals=tb_locals
+            tb_locals=tb_locals,
         )
 
     def run(self, test):
@@ -130,41 +143,46 @@ def run(self, test):
         elapsed = time.time() - start_time
 
         # Print summary
-        self.stream.write('\n')
-        self.stream.write('═' * 43)
-        self.stream.write('\n')
+        self.stream.write("\n")
+        self.stream.write("═" * 43)
+        self.stream.write("\n")
 
         # Determine summary color and message
         if result.wasSuccessful():
             color = GREEN
-            msg = f'{result.testsRun} tests passed in {elapsed:.2f}s'
+            msg = f"{result.testsRun} tests passed in {elapsed:.2f}s"
         else:
             color = RED
-            passed = result.testsRun - len(result.failures) - len(result.errors) - len(result.skipped)
+            passed = (
+                result.testsRun
+                - len(result.failures)
+                - len(result.errors)
+                - len(result.skipped)
+            )
             failed = len(result.failures) + len(result.errors)
-            parts = [f'{passed} passed', f'{failed} failed']
+            parts = [f"{passed} passed", f"{failed} failed"]
             if result.skipped:
-                parts.append(f'{len(result.skipped)} skipped')
-            msg = f'{", ".join(parts)} in {elapsed:.2f}s'
+                parts.append(f"{len(result.skipped)} skipped")
+            msg = f"{', '.join(parts)} in {elapsed:.2f}s"
 
-        self.stream.write(f'{color}{msg}{RESET}\n')
-        self.stream.write('═' * 43)
-        self.stream.write('\n')
+        self.stream.write(f"{color}{msg}{RESET}\n")
+        self.stream.write("═" * 43)
+        self.stream.write("\n")
 
         return result
 
 
 def run_tests():
     """Discover and run all tests with colorized output."""
     loader = unittest.TestLoader()
-    start_dir = 'tests'
-    suite = loader.discover(start_dir, pattern='test_*.py')
+    start_dir = "tests"
+    suite = loader.discover(start_dir, pattern="test_*.py")
 
     runner = ColorTestRunner(verbosity=2)
     result = runner.run(suite)
 
     return 0 if result.wasSuccessful() else 1
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(run_tests())

tests/test_concurrency.py

@@ -66,7 +66,9 @@ def worker():
                 start_barrier.wait()
                 session_start.main()
 
-        with mock.patch.dict(os.environ, {"CLAUDE_ENV_FILE": str(env_file)}, clear=True):
+        with mock.patch.dict(
+            os.environ, {"CLAUDE_ENV_FILE": str(env_file)}, clear=True
+        ):
             with mock.patch("builtins.open", side_effect=slow_open):
                 threads = [threading.Thread(target=worker) for _ in range(2)]
                 for t in threads:
@@ -111,21 +113,28 @@ def slow_copy(src, dst, *, follow_symlinks=True):
 
         def worker(content: str):
             thread_local.content = content
-            with mock.patch("sys.stdin", io.StringIO(json.dumps({"transcript_path": str(transcript)}))):
+            with mock.patch(
+                "sys.stdin",
+                io.StringIO(json.dumps({"transcript_path": str(transcript)})),
+            ):
                 start_barrier.wait()
                 export_plan.main()
 
         with mock.patch("pathlib.Path.home", return_value=home_dir):
             with mock.patch("pathlib.Path.cwd", return_value=project_dir):
                 with mock.patch("shutil.copy2", side_effect=slow_copy):
-                    threads = [threading.Thread(target=worker, args=(c,)) for c in contents]
+                    threads = [
+                        threading.Thread(target=worker, args=(c,)) for c in contents
+                    ]
                     for t in threads:
                         t.start()
                     for t in threads:
                         t.join()
 
         dest_file = project_dir / f"plan-{slug}.md"
-        dest_content = dest_file.read_text(encoding="utf-8") if dest_file.exists() else ""
+        dest_content = (
+            dest_file.read_text(encoding="utf-8") if dest_file.exists() else ""
+        )
         self.assertIn(dest_content, contents)
 
     def test_read_while_write_returns_slug(self) -> None:
@@ -190,4 +199,5 @@ def disappearing_copy(src, dst, *, follow_symlinks=True):
 
 if __name__ == "__main__":
     import unittest
+
     unittest.main()