Step: Create .gemini/hooks/pre-commit.py and tests

Author: apiad

.gemini/hooks/pre-commit.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+import os
+import subprocess
+import sys
+from datetime import date
+
+def run_command(command):
+    result = subprocess.run(command, capture_output=True, text=True, shell=True)
+    return result
+
+def main():
+    today = date.today().strftime("%Y-%m-%d")
+    journal_path = f"journal/{today}.md"
+    
+    # Scan for changes (staged, modified, untracked)
+    # git ls-files --modified --others --exclude-standard
+    res = run_command("git ls-files --modified --others --exclude-standard")
+    changed_files = res.stdout.strip().splitlines()
+    
+    if not changed_files:
+        return 0
+    
+    # Calculate max(mtime) for all changed files (excluding .gemini/ and the journal)
+    meaningful_changes = [f for f in changed_files if not f.startswith(".gemini/") and f != journal_path]
+    
+    if not meaningful_changes:
+        return 0
+    
+    max_mtime = 0
+    for f in meaningful_changes:
+        if os.path.exists(f):
+            mtime = os.path.getmtime(f)
+            if mtime > max_mtime:
+                max_mtime = mtime
+    
+    # Check journal mtime
+    if not os.path.exists(journal_path):
+        print(f"Error: Updated journal required ({journal_path} does not exist)")
+        return 1
+    
+    journal_mtime = os.path.getmtime(journal_path)
+    
+    if journal_mtime < max_mtime:
+        print("Error: Updated journal required (Today's journal must be the most recently modified file)")
+        return 1
+    
+    # Run make
+    print("Running validation (make test)...")
+    res = run_command("make test")
+    if res.returncode != 0:
+        print("Validation failed:")
+        print(res.stdout)
+        print(res.stderr)
+        return res.returncode
+    
+    print("Validation passed.")
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

TASKS.md

@@ -17,7 +17,7 @@ Put done tasks into the Archive.
 ---
 
 ## Active Tasks
-- [ ] Consolidate project hooks into a single Git pre-commit hook (See plan: plans/consolidate-hooks.md)
+- [/] Consolidate project hooks into a single Git pre-commit hook (@apiad) (See plan: plans/consolidate-hooks.md)
 
 ---
 

makefile

@@ -4,6 +4,7 @@ all: test lint
 
 test:
 	@echo "Running tests..."
+	python3 tests/test_hooks.py
 
 docs-serve:
 	@mkdocs serve

tests/test_hooks.py

@@ -0,0 +1,119 @@
+import os
+import unittest
+import subprocess
+import shutil
+import time
+from datetime import date
+
+class TestPreCommitHook(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = "temp_test_repo"
+        if os.path.exists(self.test_dir):
+            shutil.rmtree(self.test_dir)
+        os.makedirs(self.test_dir)
+        os.chdir(self.test_dir)
+        subprocess.run(["git", "init"], capture_output=True)
+        # Configure user for testing
+        subprocess.run(["git", "config", "user.email", "test@example.com"], capture_output=True)
+        subprocess.run(["git", "config", "user.name", "Test User"], capture_output=True)
+        
+        os.makedirs(".gemini/hooks")
+        os.makedirs("journal")
+        
+        # Initial commit
+        with open(".gitignore", "w") as f:
+            f.write("temp_test_repo/\n")
+        subprocess.run(["git", "add", ".gitignore"], capture_output=True)
+        subprocess.run(["git", "commit", "-m", "Initial commit"], capture_output=True)
+        
+    def tearDown(self):
+        os.chdir("..")
+        if os.path.exists(self.test_dir):
+            shutil.rmtree(self.test_dir)
+
+    def test_journal_mtime_validation(self):
+        # Create a journal entry
+        today = date.today().strftime("%Y-%m-%d")
+        journal_path = f"journal/{today}.md"
+        with open(journal_path, "w") as f:
+            f.write("Journal entry")
+        
+        # Ensure mtime is set
+        time.sleep(0.1)
+        
+        # Create a modified file
+        with open("code.py", "w") as f:
+            f.write("Code change")
+            
+        # Hook should fail because code.py is newer than journal
+        # We'll run the pre-commit hook script directly
+        result = subprocess.run(["python3", "../.gemini/hooks/pre-commit.py"], capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("Updated journal required", result.stdout + result.stderr)
+
+    def test_journal_mtime_validation_success(self):
+        # Add a dummy makefile to the test repo to avoid failure when running make test
+        with open("makefile", "w") as f:
+            f.write("test:\n\t@echo 'Tests passed'")
+            
+        # Create a modified file
+        with open("code.py", "w") as f:
+            f.write("Code change")
+            
+        # Create a journal entry AFTER the file modification
+        time.sleep(0.1)
+        today = date.today().strftime("%Y-%m-%d")
+        journal_path = f"journal/{today}.md"
+        with open(journal_path, "w") as f:
+            f.write("Journal entry updated")
+            
+        # Hook should succeed
+        result = subprocess.run(["python3", "../.gemini/hooks/pre-commit.py"], capture_output=True, text=True)
+        if result.returncode != 0:
+            print(f"\nHOOK FAILED (rc={result.returncode})")
+            print(f"STDOUT: {result.stdout}")
+            print(f"STDERR: {result.stderr}")
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("Validation passed", result.stdout)
+
+    def test_make_failure(self):
+        # Add a failing makefile
+        with open("makefile", "w") as f:
+            f.write("test:\n\t@exit 1")
+            
+        # Create a journal entry
+        today = date.today().strftime("%Y-%m-%d")
+        journal_path = f"journal/{today}.md"
+        with open(journal_path, "w") as f:
+            f.write("Journal entry")
+            
+        # Ensure journal is newest
+        time.sleep(0.1)
+        os.utime(journal_path, None)
+        
+        # Hook should fail because make test fails
+        result = subprocess.run(["python3", "../.gemini/hooks/pre-commit.py"], capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("Validation failed", result.stdout)
+
+    def test_ignore_gemini_files(self):
+        # Create a journal entry
+        today = date.today().strftime("%Y-%m-%d")
+        journal_path = f"journal/{today}.md"
+        with open(journal_path, "w") as f:
+            f.write("Journal entry")
+            
+        time.sleep(0.1)
+        
+        # Modify a .gemini file
+        with open(".gemini/settings.json", "w") as f:
+            f.write("{}")
+            
+        # Hook should succeed because .gemini file is ignored in mtime check
+        result = subprocess.run(["python3", "../.gemini/hooks/pre-commit.py"], capture_output=True, text=True)
+        # It might fail because make test fails (no makefile)
+        # But it shouldn't fail with "Updated journal required"
+        self.assertNotIn("Updated journal required", result.stdout + result.stderr)
+
+if __name__ == "__main__":
+    unittest.main()