Hooks Guide

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"No description\")\"' >> ~/.claude/bash-command-log.txt"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/markdown_formatter.py"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env python3
"""
Markdown formatter for Claude Code output.
Fixes missing language tags and spacing issues while preserving code content.
"""
import json
import sys
import re
import os
 
def detect_language(code):
    """Best-effort language detection from code content."""
    s = code.strip()
 
    # JSON detection
    if re.search(r'^\\s*[{\\[]', s):
        try:
            json.loads(s)
            return 'json'
        except:
            pass
 
    # Python detection
    if re.search(r'^\\s*def\\s+\\w+\\s*\\(', s, re.M) or \
       re.search(r'^\\s*(import|from)\\s+\\w+', s, re.M):
        return 'python'
 
    # JavaScript detection
    if re.search(r'\\b(function\\s+\\w+\\s*\\(|const\\s+\\w+\\s*=)', s) or \
       re.search(r'=>|console\\.(log|error)', s):
        return 'javascript'
 
    # Bash detection
    if re.search(r'^#!.*\\b(bash|sh)\\b', s, re.M) or \
       re.search(r'\\b(if|then|fi|for|in|do|done)\\b', s):
        return 'bash'
 
    return 'text'
 
def format_markdown(content):
    """Format markdown content with language detection."""
    # Fix unlabeled code fences
    def add_lang_to_fence(match):
        indent, info, body, closing = match.groups()
        if not info.strip():
            lang = detect_language(body)
            return f"{indent}```{lang}\\n{body}{closing}\\n"
        return match.group(0)
 
    fence_pattern = r'(?ms)^([ \\t]{0,3})```([^\\n]*)\\n(.*?)(\\n\\1```)\\s*$'
    content = re.sub(fence_pattern, add_lang_to_fence, content)
 
    # Fix excessive blank lines
    content = re.sub(r'\\n{3,}', '\\n\\n', content)
 
    return content.rstrip() + '\\n'
 
# Main execution
try:
    input_data = json.load(sys.stdin)
    file_path = input_data.get('tool_input', {}).get('file_path', '')
 
    if not file_path.endswith(('.md', '.mdx')):
        sys.exit(0)  # Not a markdown file
 
    if os.path.exists(file_path):
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
 
        formatted = format_markdown(content)
 
        if formatted != content:
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(formatted)
            print(f"✓ Fixed markdown formatting in {file_path}")
 
except Exception as e:
    print(f"Error formatting markdown: {e}", file=sys.stderr)
    sys.exit(1)

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Awaiting your input'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import json, sys; data=json.load(sys.stdin); path=data.get('tool_input',{}).get('file_path',''); sys.exit(2 if any(p in path for p in ['.env', 'package-lock.json', '.git/']) else 0)\""
          }
        ]
      }
    ]
  }
}

ralph:
  enabled: true
  hooks:
    post_tool_lsp:
      enabled: true
      severity_threshold: error  # error | warning | info

ralph:
  enabled: true
  loop:
    max_iterations: 10
    auto_fix: false
    completion:
      zero_errors: true
      zero_warnings: false
      tests_pass: true
      coverage_threshold: 85

constitution:
  quality_gate:
    max_errors: 0
    max_warnings: 10
    enabled: true

{
  "lsp_errors": 0,
  "lsp_warnings": 2,
  "type_errors": 0,
  "lint_errors": 0,
  "passed": true,
  "reason": "Quality gate passed: LSP diagnostics clean"
}

.claude/hooks/moai/lib/
├── __init__.py
├── atomic_write.py           # Atomic write operations
├── checkpoint.py             # Checkpoint management
├── common.py                 # Common utilities
├── config.py                 # Configuration management
├── config_manager.py         # Configuration manager (advanced)
├── config_validator.py       # Configuration validation
├── context_manager.py        # Context management (snapshots, archives)
├── enhanced_output_style_detector.py  # Output style detection
├── file_utils.py             # File utilities
├── git_collector.py          # Git data collection
├── git_operations_manager.py # Git operations manager (optimized)
├── language_detector.py      # Language detection
├── language_validator.py     # Language validation
├── main.py                   # Main entry point
├── memory_collector.py       # Memory collection
├── metrics_tracker.py        # Metrics tracking
├── models.py                 # Data models
├── path_utils.py             # Path utilities
├── project.py                # Project-related
├── renderer.py               # Renderer
├── timeout.py                # Timeout handling
├── tool_registry.py          # Tool registry (formatters, linters)
├── unified_timeout_manager.py # Unified timeout manager
├── update_checker.py         # Update check
├── version_reader.py         # Version reading
├── alfred_detector.py        # Alfred detection
└── shared/utils/
    └── announcement_translator.py  # Announcement translation

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/session_start__show_project_info.py\"'"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/pre_tool__security_guard.py\"'",
            "timeout": 5000
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/post_tool__code_formatter.py\"'",
            "timeout": 30000
          },
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/post_tool__linter.py\"'",
            "timeout": 60000
          },
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/post_tool__ast_grep_scan.py\"'",
            "timeout": 30000
          },
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/post_tool__lsp_diagnostic.py\"'"
          }
        ]
      }
    ],
    "PreCompact": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/pre_compact__save_context.py\"'",
            "timeout": 5000
          }
        ]
      }
    ],
    "SessionEnd": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/session_end__auto_cleanup.py\"'",
            "timeout": 5000
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "${SHELL:-/bin/bash} -l -c 'uv run \"$CLAUDE_PROJECT_DIR/.claude/hooks/moai/stop__loop_controller.py\"'"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env python3
"""Custom PostToolUse Hook: Perform specific checks after file modification"""
 
import json
import sys
 
 
def main():
    # Read Hook input data from stdin
    input_data = json.loads(sys.stdin.read())
 
    tool_name = input_data.get("tool_name", "")
    tool_input = input_data.get("tool_input", {})
    file_path = tool_input.get("file_path", "")
 
    # Check logic
    if file_path.endswith(".py"):
        # Custom check for Python files
        result = check_python_file(file_path)
 
        if result["has_issues"]:
            # Send feedback to Claude Code
            output = {
                "hookSpecificOutput": {
                  "hookEventName": "PostToolUse",
                  "additionalContext": result["message"]
                }
            }
            print(json.dumps(output))
            return
 
    # Suppress output if no issues
    output = {"suppressOutput": True}
    print(json.dumps(output))
 
 
def check_python_file(file_path: str) -> dict:
    """Custom Python file check"""
    # Implement check logic
    return {"has_issues": False, "message": ""}
 
 
if __name__ == "__main__":
    main()

{
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "File content..."
  },
  "tool_output": "File output result (PostToolUse only)"
}

.claude/hooks/moai/
├── __init__.py                        # Package initialization
├── session_start__show_project_info.py # Session start
├── pre_tool__security_guard.py         # Security guard
├── post_tool__code_formatter.py        # Code formatter
├── post_tool__linter.py                # Linter
├── post_tool__ast_grep_scan.py         # AST-grep scan
├── post_tool__lsp_diagnostic.py        # LSP diagnostics
├── pre_compact__save_context.py        # Context save
├── session_end__auto_cleanup.py        # Auto cleanup

├── stop__loop_controller.py            # Loop controller
├── quality_gate_with_lsp.py            # Quality gate
└── lib/                                # Shared library
    ├── atomic_write.py                 # Atomic write
    ├── checkpoint.py                   # Checkpoint
    ├── common.py                       # Common utilities
    ├── config.py                       # Config
    ├── config_manager.py               # Config manager
    ├── config_validator.py             # Config validation
    ├── context_manager.py              # Context management
    ├── git_operations_manager.py       # Git operations manager
    ├── tool_registry.py                # Tool registry
    ├── unified_timeout_manager.py      # Timeout manager
    └── ...                             # Other modules

export MOAI_DISABLE_AST_GREP_SCAN=1