refactor(hooks): centralize shared logic into utils.py and rename hooks

Author: apiad

.gemini/hooks/check_make.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+Hook to enforce project journaling for all significant changes.
+
+This hook is triggered 'AfterAgent' and checks if the daily journal entry has been updated
+whenever there are uncommitted changes in the repository.
+"""
+import sys
+import os
+from datetime import datetime
+
+# Add the hooks directory to path for importing utils
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import utils
+
+def main():
+    """
+    Main entry point for the journal enforcement hook.
+    
+    Checks git status for uncommitted changes and identifies if the current daily journal
+    has been updated accordingly. Returns 'deny' if it's missing.
+    """
+    try:
+        modified_files = utils.get_modified_files()
+        
+        today = datetime.now().strftime("%Y-%m-%d")
+        journal_file = f"journal/{today}.md"
+
+        # Check if there are changes other than the daily journal
+        significant_changes = [
+            f for f in modified_files
+            if f != journal_file
+        ]
+
+        # Check if the daily journal was updated
+        journal_updated = journal_file in modified_files
+
+        if significant_changes and not journal_updated:
+            utils.send_hook_decision(
+                "deny",
+                reason=(
+                    f"Please add a one-line entry to {journal_file} "
+                    "describing the changes you just made. Do not stop until this file is updated."
+                )
+            )
+        else:
+            utils.send_hook_decision("allow")
+
+    except Exception:
+        # Failsafe: always allow if something goes wrong
+        utils.send_hook_decision("allow")
+
+if __name__ == "__main__":
+    main()

.gemini/hooks/enforce_journal.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+Hook to log agent model output to the session log file for debugging and auditing.
+
+This hook is triggered after the model response and processes JSON from stdin.
+The 'decision' is always 'allow'.
+"""
+import sys
+import os
+import json
+
+# Add the hooks directory to path for importing utils
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import utils
+
+def main():
+    """
+    Main entry point for the log model output hook.
+    
+    Reads candidate model responses from stdin and appends them to the log file.
+    """
+    try:
+        input_data = sys.stdin.read()
+        if not input_data:
+            utils.send_hook_decision("allow")
+            return
+
+        data = json.loads(input_data)
+        llm_response = data.get("llm_response", {})
+        candidates = llm_response.get("candidates", [])
+        
+        if candidates:
+            candidate = candidates[0]
+            content_obj = candidate.get("content", {})
+            parts = content_obj.get("parts", [])
+            finish_reason = candidate.get("finishReason")
+
+            if parts or finish_reason:
+                content_to_log = ""
+                for part in parts:
+                    if isinstance(part, str):
+                        content_to_log += part
+                    elif isinstance(part, dict) and "text" in part:
+                        content_to_log += part["text"]
+                if finish_reason:
+                    content_to_log += "\n\n"
+                
+                utils.log_message(content_to_log, mode="a")
+
+        utils.send_hook_decision("allow")
+
+    except Exception:
+        # Failsafe: always allow if something goes wrong
+        utils.send_hook_decision("allow")
+
+if __name__ == "__main__":
+    main()

.gemini/hooks/journal.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Hook to run 'make' validation before critical agent actions.
+
+This hook is triggered 'AfterAgent' and ensures that the codebase passes
+all linting and testing checks defined in the makefile.
+"""
+import sys
+import os
+import subprocess
+
+# Add the hooks directory to path for importing utils
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import utils
+
+def main():
+    """
+    Main entry point for the make validation hook.
+    
+    Executes 'uv run make' and returns a 'deny' decision if the process fails.
+    """
+    try:
+        # Run make command using uv run to ensure dependencies are available
+        result = subprocess.run(
+            ["uv", "run", "make"],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+
+        if result.returncode != 0:
+            # make failed
+            error_message = result.stdout + "\n" + result.stderr
+            reason = (
+                f"Validation failed (make returned {result.returncode}).\n"
+                "Please fix the broken tests or linting issues.\n"
+                "Output of 'make':\n"
+                "```\n" + error_message.strip() + "\n```\n"
+                "Fix these issues and ensure 'make' passes before continuing."
+            )
+            utils.send_hook_decision("deny", reason=reason)
+        else:
+            # make passed
+            utils.send_hook_decision("allow")
+
+    except Exception:
+        # Failsafe: always allow if the hook itself fails
+        utils.send_hook_decision("allow")
+
+if __name__ == "__main__":
+    main()

.gemini/hooks/log.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""
+Hook to initialize the Gemini CLI session by resetting the log file.
+
+This hook is triggered on session 'startup', 'resume', or 'clear'.
+The 'decision' is always 'allow'.
+"""
+import sys
+import os
+from datetime import datetime
+
+# Add the hooks directory to path for importing utils
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import utils
+
+def main():
+    """
+    Main entry point for the session start hook.
+
+    Resets the session log file with a timestamped entry.
+    """
+    try:
+        utils.log_message(
+            f"--- Session Started ({datetime.now().strftime('%Y-%m-%d %H:%M:%S')}) ---",
+            mode="w"
+        )
+        utils.send_hook_decision("allow")
+    except Exception:
+        # Failsafe: always allow if something goes wrong
+        utils.send_hook_decision("allow")
+
+if __name__ == "__main__":
+    main()