claude-scripts/setup_global_hook.sh

#!/bin/bash

# Setup script to make the code quality hook globally accessible from ~/repos projects
# This script creates a global Claude Code configuration that references the hook

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
HOOK_DIR="$SCRIPT_DIR/hooks"
HOOK_SCRIPT="$HOOK_DIR/code_quality_guard.py"
GLOBAL_CONFIG_DIR="$HOME/.claude"
GLOBAL_CONFIG_FILE="$GLOBAL_CONFIG_DIR/claude-code-settings.json"

# Colors for output
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color

echo -e "${YELLOW}Setting up global Claude Code quality hook...${NC}"

# Check if hook script exists
if [ ! -f "$HOOK_SCRIPT" ]; then
    echo -e "${RED}Error: Hook script not found at $HOOK_SCRIPT${NC}"
    exit 1
fi

# Create Claude config directory if it doesn't exist
if [ ! -d "$GLOBAL_CONFIG_DIR" ]; then
    echo "Creating Claude configuration directory at $GLOBAL_CONFIG_DIR"
    mkdir -p "$GLOBAL_CONFIG_DIR"
fi

# Backup existing global config if it exists
if [ -f "$GLOBAL_CONFIG_FILE" ]; then
    BACKUP_FILE="${GLOBAL_CONFIG_FILE}.backup.$(date +%Y%m%d_%H%M%S)"
    echo "Backing up existing configuration to $BACKUP_FILE"
    cp "$GLOBAL_CONFIG_FILE" "$BACKUP_FILE"
fi

# Create the global configuration
cat > "$GLOBAL_CONFIG_FILE" << EOF
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "cd $HOOK_DIR && python code_quality_guard.py"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "cd $HOOK_DIR && python code_quality_guard.py"
          }
        ]
      }
    ]
  }
}
EOF

echo -e "${GREEN}✓ Global Claude Code configuration created at $GLOBAL_CONFIG_FILE${NC}"

# Create a convenience script to configure quality settings
QUALITY_CONFIG_SCRIPT="$HOME/.claude/configure-quality.sh"
cat > "$QUALITY_CONFIG_SCRIPT" << 'EOF'
#!/bin/bash

# Convenience script to configure code quality hook settings
# Usage: source ~/.claude/configure-quality.sh [preset]

case "${1:-default}" in
    strict)
        export QUALITY_ENFORCEMENT="strict"
        export QUALITY_COMPLEXITY_THRESHOLD="10"
        export QUALITY_DUP_THRESHOLD="0.7"
        export QUALITY_DUP_ENABLED="true"
        export QUALITY_COMPLEXITY_ENABLED="true"
        export QUALITY_MODERN_ENABLED="true"
        export QUALITY_TYPE_HINTS="true"
        echo "✓ Strict quality mode enabled"
        ;;

    moderate)
        export QUALITY_ENFORCEMENT="warn"
        export QUALITY_COMPLEXITY_THRESHOLD="15"
        export QUALITY_DUP_THRESHOLD="0.8"
        export QUALITY_DUP_ENABLED="true"
        export QUALITY_COMPLEXITY_ENABLED="true"
        export QUALITY_MODERN_ENABLED="true"
        export QUALITY_TYPE_HINTS="false"
        echo "✓ Moderate quality mode enabled"
        ;;

    permissive)
        export QUALITY_ENFORCEMENT="permissive"
        export QUALITY_COMPLEXITY_THRESHOLD="20"
        export QUALITY_DUP_THRESHOLD="0.9"
        export QUALITY_DUP_ENABLED="true"
        export QUALITY_COMPLEXITY_ENABLED="true"
        export QUALITY_MODERN_ENABLED="false"
        export QUALITY_TYPE_HINTS="false"
        echo "✓ Permissive quality mode enabled"
        ;;

    disabled)
        export QUALITY_ENFORCEMENT="permissive"
        export QUALITY_DUP_ENABLED="false"
        export QUALITY_COMPLEXITY_ENABLED="false"
        export QUALITY_MODERN_ENABLED="false"
        echo "✓ Quality checks disabled"
        ;;

    custom)
        echo "Configure custom quality settings:"
        read -p "Enforcement mode (strict/warn/permissive): " QUALITY_ENFORCEMENT
        read -p "Complexity threshold (10-30): " QUALITY_COMPLEXITY_THRESHOLD
        read -p "Duplicate threshold (0.5-1.0): " QUALITY_DUP_THRESHOLD
        read -p "Enable duplicate detection? (true/false): " QUALITY_DUP_ENABLED
        read -p "Enable complexity checks? (true/false): " QUALITY_COMPLEXITY_ENABLED
        read -p "Enable modernization checks? (true/false): " QUALITY_MODERN_ENABLED
        read -p "Require type hints? (true/false): " QUALITY_TYPE_HINTS

        export QUALITY_ENFORCEMENT
        export QUALITY_COMPLEXITY_THRESHOLD
        export QUALITY_DUP_THRESHOLD
        export QUALITY_DUP_ENABLED
        export QUALITY_COMPLEXITY_ENABLED
        export QUALITY_MODERN_ENABLED
        export QUALITY_TYPE_HINTS

        echo "✓ Custom quality settings configured"
        ;;

    status)
        echo "Current quality settings:"
        echo "  QUALITY_ENFORCEMENT: ${QUALITY_ENFORCEMENT:-strict}"
        echo "  QUALITY_COMPLEXITY_THRESHOLD: ${QUALITY_COMPLEXITY_THRESHOLD:-10}"
        echo "  QUALITY_DUP_THRESHOLD: ${QUALITY_DUP_THRESHOLD:-0.7}"
        echo "  QUALITY_DUP_ENABLED: ${QUALITY_DUP_ENABLED:-true}"
        echo "  QUALITY_COMPLEXITY_ENABLED: ${QUALITY_COMPLEXITY_ENABLED:-true}"
        echo "  QUALITY_MODERN_ENABLED: ${QUALITY_MODERN_ENABLED:-true}"
        echo "  QUALITY_TYPE_HINTS: ${QUALITY_TYPE_HINTS:-false}"
        return 0
        ;;

    *)
        # Default settings
        export QUALITY_ENFORCEMENT="strict"
        export QUALITY_COMPLEXITY_THRESHOLD="10"
        export QUALITY_DUP_THRESHOLD="0.7"
        export QUALITY_DUP_ENABLED="true"
        export QUALITY_COMPLEXITY_ENABLED="true"
        export QUALITY_MODERN_ENABLED="true"
        export QUALITY_TYPE_HINTS="false"
        echo "✓ Default quality settings applied"

        echo ""
        echo "Available presets:"
        echo "  strict    - Strict quality enforcement (default)"
        echo "  moderate  - Moderate quality checks with warnings"
        echo "  permissive - Permissive mode with suggestions"
        echo "  disabled  - Disable all quality checks"
        echo "  custom    - Configure custom settings"
        echo "  status    - Show current settings"
        echo ""
        echo "Usage: source ~/.claude/configure-quality.sh [preset]"
        ;;
esac

# Enable post-tool features for better feedback
export QUALITY_STATE_TRACKING="true"
export QUALITY_CROSS_FILE_CHECK="true"
export QUALITY_VERIFY_NAMING="true"
export QUALITY_SHOW_SUCCESS="false"  # Keep quiet unless there are issues
EOF

chmod +x "$QUALITY_CONFIG_SCRIPT"
echo -e "${GREEN}✓ Quality configuration script created at $QUALITY_CONFIG_SCRIPT${NC}"

# Add convenience alias to shell configuration
SHELL_RC=""
if [ -f "$HOME/.bashrc" ]; then
    SHELL_RC="$HOME/.bashrc"
elif [ -f "$HOME/.zshrc" ]; then
    SHELL_RC="$HOME/.zshrc"
fi

if [ -n "$SHELL_RC" ]; then
    # Check if alias already exists
    if ! grep -q "alias claude-quality" "$SHELL_RC" 2>/dev/null; then
        echo "" >> "$SHELL_RC"
        echo "# Claude Code quality configuration" >> "$SHELL_RC"
        echo "alias claude-quality='source ~/.claude/configure-quality.sh'" >> "$SHELL_RC"
        echo -e "${GREEN}✓ Added 'claude-quality' alias to $SHELL_RC${NC}"
    fi
fi

# Test the hook installation
echo ""
echo -e "${YELLOW}Testing hook installation...${NC}"
cd "$HOOK_DIR"
TEST_OUTPUT=$(echo '{"tool_name":"Read","tool_input":{}}' | python code_quality_guard.py 2>&1)
if echo "$TEST_OUTPUT" | grep -q '"decision"'; then
    echo -e "${GREEN}✓ Hook is working correctly${NC}"
else
    echo -e "${RED}✗ Hook test failed. Output:${NC}"
    echo "$TEST_OUTPUT"
    exit 1
fi

# Create a README for the global setup
cat > "$GLOBAL_CONFIG_DIR/README_QUALITY_HOOK.md" << EOF
# Claude Code Quality Hook

The code quality hook is now globally configured for all projects in ~/repos.

## Configuration

The hook automatically runs on PreToolUse and PostToolUse events for Write, Edit, and MultiEdit operations.

### Quick Configuration

Use the \`claude-quality\` command to quickly configure quality settings:

\`\`\`bash
# Apply a preset
source ~/.claude/configure-quality.sh strict    # Strict enforcement
source ~/.claude/configure-quality.sh moderate  # Moderate with warnings
source ~/.claude/configure-quality.sh permissive # Permissive suggestions
source ~/.claude/configure-quality.sh disabled  # Disable checks

# Or use the alias
claude-quality strict

# Check current settings
claude-quality status
\`\`\`

### Environment Variables

You can also set these environment variables directly:

- \`QUALITY_ENFORCEMENT\`: strict/warn/permissive
- \`QUALITY_COMPLEXITY_THRESHOLD\`: Maximum cyclomatic complexity (default: 10)
- \`QUALITY_DUP_THRESHOLD\`: Duplicate similarity threshold 0-1 (default: 0.7)
- \`QUALITY_DUP_ENABLED\`: Enable duplicate detection (default: true)
- \`QUALITY_COMPLEXITY_ENABLED\`: Enable complexity checks (default: true)
- \`QUALITY_MODERN_ENABLED\`: Enable modernization checks (default: true)
- \`QUALITY_TYPE_HINTS\`: Require type hints (default: false)
- \`QUALITY_STATE_TRACKING\`: Track file state changes (default: true)
- \`QUALITY_CROSS_FILE_CHECK\`: Check cross-file duplicates (default: true)
- \`QUALITY_VERIFY_NAMING\`: Verify PEP8 naming (default: true)
- \`QUALITY_SHOW_SUCCESS\`: Show success messages (default: false)

### Per-Project Configuration

To override settings for a specific project, add a \`.quality.env\` file to the project root:

\`\`\`bash
# .quality.env
QUALITY_ENFORCEMENT=moderate
QUALITY_COMPLEXITY_THRESHOLD=15
\`\`\`

Then source it: \`source .quality.env\`

## Features

### PreToolUse Checks
- Internal duplicate detection within files
- Cyclomatic complexity analysis
- Code modernization suggestions
- Type hint requirements

### PostToolUse Checks
- State tracking (detects quality degradation)
- Cross-file duplicate detection
- PEP8 naming convention verification

## Enforcement Modes

- **strict**: Blocks (deny) code that fails quality checks
- **warn**: Asks for confirmation (ask) on quality issues
- **permissive**: Allows code with warnings

## Troubleshooting

If the hook is not working:
1. Check that claude-quality binary is installed: \`which claude-quality\`
2. Verify Python environment: \`python --version\`
3. Test the hook directly: \`echo '{"tool_name":"Read","tool_input":{}}' | python $HOOK_DIR/code_quality_guard.py\`
4. Check logs: Claude Code may show hook errors in its output

## Uninstalling

To remove the global hook:
1. Delete or rename ~/.claude/claude-code-settings.json
2. Remove the claude-quality alias from your shell RC file
EOF

echo ""
echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}✓ Global code quality hook successfully installed!${NC}"
echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo "The hook is now active for all Claude Code sessions in ~/repos projects."
echo ""
echo "Quick start:"
echo -e "  ${YELLOW}claude-quality strict${NC}     # Enable strict quality enforcement"
echo -e "  ${YELLOW}claude-quality moderate${NC}   # Use moderate settings"
echo -e "  ${YELLOW}claude-quality status${NC}     # Check current settings"
echo ""
echo "For more information, see: ~/.claude/README_QUALITY_HOOK.md"
echo ""
echo -e "${YELLOW}Note: Restart your shell or run 'source $SHELL_RC' to use the claude-quality alias${NC}"