claude-git-hooks 1.5.4 → 2.0.0

package/templates/pre-commit

@@ -1,432 +1,79 @@
 #!/bin/bash
 
-# Git Pre-commit Hook for code evaluation with Claude CLI
-# Archivo: .git/hooks/pre-commit
+# Git Pre-commit Hook - Node.js Wrapper
+# This is a minimal wrapper that calls the actual Node.js implementation
+# Why: Allows the Node.js script to use relative imports from its installed location
 
 set -e
 
-# Configuration
-CLAUDE_CLI="claude"
-TEMP_DIR="/tmp/code-review-$$"
-MAX_FILE_SIZE=100000  # 100KB maximum per file
-
 # Colors for output
 RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Function for logging
-log() {
-    echo -e "${GREEN}[PRE-COMMIT]${NC} $1"
-}
-
-error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
+NC='\033[0m'
+
+# Convert Windows path to Git Bash/WSL path
+# Why: npm prefix -g in Git Bash returns Windows paths (C:\...) that need conversion
+convert_windows_path() {
+    local path="$1"
+
+    # Check if it's a Windows path (contains :\ or starts with C:)
+    if [[ "$path" =~ ^[A-Za-z]:\\ ]] || [[ "$path" =~ ^[A-Za-z]: ]]; then
+        # Convert C:\path\to\file to /c/path/to/file
+        # First, extract drive letter
+        local drive=$(echo "$path" | sed 's/^\([A-Za-z]\):.*/\1/' | tr '[:upper:]' '[:lower:]')
+        # Remove drive letter and colon, replace backslashes with forward slashes
+        local rest=$(echo "$path" | sed 's/^[A-Za-z]://' | sed 's/\\/\//g')
+        echo "/$drive$rest"
+    else
+        echo "$path"
+    fi
 }
 
-# Check version at start (before any analysis)
-# Try to find the check-version.sh script
-CHECK_VERSION_SCRIPT=""
-# Search in multiple possible locations
-SCRIPT_PATHS=(
-    "$(dirname "$0")/check-version.sh"
-    "/usr/local/lib/node_modules/claude-git-hooks/templates/check-version.sh"
-    "/usr/lib/node_modules/claude-git-hooks/templates/check-version.sh"
-    "$HOME/.npm-global/lib/node_modules/claude-git-hooks/templates/check-version.sh"
-    "$(npm prefix -g 2>/dev/null)/lib/node_modules/claude-git-hooks/templates/check-version.sh"
-)
+# Function to find the Node.js script
+find_hook_script() {
+    # Why: Try multiple locations to find where npm installed the package
+    # Checks: global npm, local node_modules, npm prefix
 
-for path in "${SCRIPT_PATHS[@]}"; do
-    if [ -f "$path" ]; then
-        CHECK_VERSION_SCRIPT="$path"
-        break
+    # Get npm global prefix and convert if it's a Windows path
+    local npm_prefix=$(npm prefix -g 2>/dev/null || echo "")
+    if [ -n "$npm_prefix" ]; then
+        npm_prefix=$(convert_windows_path "$npm_prefix")
     fi
-done
-
-# If we find the script, execute it
-if [ -n "$CHECK_VERSION_SCRIPT" ]; then
-    # Source the script to have access to the function
-    source "$CHECK_VERSION_SCRIPT"
-    check_version
-fi
 
-# Function to generate AI-friendly resolution prompt
-generate_resolution_prompt() {
-    local RESOLUTION_FILE="./claude_resolution_prompt.md"
-    local RESOLUTION_TEMPLATE=".claude/CLAUDE_RESOLUTION_PROMPT.md"
-    
-    if [ ! -f "$RESOLUTION_TEMPLATE" ]; then
-        warning "Resolution template not found: $RESOLUTION_TEMPLATE"
-        return
-    fi
-    
-    # Get context information
-    local REPO_NAME=$(basename $(git rev-parse --show-toplevel))
-    local BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
-    local COMMIT_SHA="pending"
-    local FILE_COUNT=$(echo "$JAVA_FILES" | wc -l)
-    
-    # Format the blocking issues for the resolution prompt
-    local ISSUES_FORMATTED=""
-    local issue_num=1
-    
-    # Use a temporary file to accumulate the issues
-    local TEMP_ISSUES=$(mktemp)
-    
-    # Parse each blocking issue as JSON object
-    echo "$JSON_RESPONSE" | jq -c '.blockingIssues[]?' 2>/dev/null | while IFS= read -r issue; do
-        if [ -n "$issue" ]; then
-            local desc=$(echo "$issue" | jq -r '.description')
-            local file=$(echo "$issue" | jq -r '.file')
-            local line=$(echo "$issue" | jq -r '.line')
-            local method=$(echo "$issue" | jq -r '.method')
-            local severity=$(echo "$issue" | jq -r '.severity')
-            
-            echo "### Issue #${issue_num} [${severity^^}]" >> "$TEMP_ISSUES"
-            echo "**Description:** ${desc}" >> "$TEMP_ISSUES"
-            echo "**Location:** ${file}:${line}" >> "$TEMP_ISSUES"
-            echo "**Method/Class:** ${method}" >> "$TEMP_ISSUES"
-            echo "" >> "$TEMP_ISSUES"
-            issue_num=$((issue_num + 1))
+    local SCRIPT_PATHS=(
+        # Global npm installation (Linux/Mac)
+        "/usr/local/lib/node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        "/usr/lib/node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        # Global npm installation (Windows) - node_modules directly under prefix
+        "${npm_prefix}/node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        # Global npm installation (Unix/WSL) - lib/node_modules under prefix
+        "${npm_prefix}/lib/node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        # Home directory npm global
+        "$HOME/.npm-global/lib/node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        # Local node_modules (if linked or installed locally)
+        "./node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+        "../node_modules/claude-git-hooks/lib/hooks/pre-commit.js"
+    )
+
+    for path in "${SCRIPT_PATHS[@]}"; do
+        if [ -f "$path" ]; then
+            echo "$path"
+            return 0
         fi
     done
-    
-    # Read the accumulated content
-    ISSUES_FORMATTED=$(cat "$TEMP_ISSUES")
-    rm -f "$TEMP_ISSUES"
-    
-    # Generate the prompt from the template
-    cp "$RESOLUTION_TEMPLATE" "$RESOLUTION_FILE"
-    
-    # Replace placeholders - use double quotes and escape special characters
-    sed -i "s|{{REPO_NAME}}|${REPO_NAME}|g" "$RESOLUTION_FILE"
-    sed -i "s|{{BRANCH_NAME}}|${BRANCH_NAME}|g" "$RESOLUTION_FILE"
-    sed -i "s|{{COMMIT_SHA}}|${COMMIT_SHA}|g" "$RESOLUTION_FILE"
-    sed -i "s|{{FILE_COUNT}}|${FILE_COUNT}|g" "$RESOLUTION_FILE"
-    
-    # Create temporary file for formatted issues
-    local TEMP_ISSUES_FILE=$(mktemp)
-    echo "$ISSUES_FORMATTED" > "$TEMP_ISSUES_FILE"
-    
-    # Replace {{BLOCKING_ISSUES}} with content
-    if [ -n "$ISSUES_FORMATTED" ]; then
-        sed -i "/{{BLOCKING_ISSUES}}/r $TEMP_ISSUES_FILE" "$RESOLUTION_FILE"
-    fi
-    sed -i "s|{{BLOCKING_ISSUES}}||g" "$RESOLUTION_FILE"
-    rm -f "$TEMP_ISSUES_FILE"
-    
-    # Add content from affected files
-    local TEMP_FILES=$(mktemp)
-    echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].file' 2>/dev/null | sort -u | while IFS= read -r file; do
-        if [ -f "$file" ]; then
-            echo "### File: $file" >> "$TEMP_FILES"
-            echo "" >> "$TEMP_FILES"
-            echo '```' >> "$TEMP_FILES"
-            cat "$file" >> "$TEMP_FILES"
-            echo '```' >> "$TEMP_FILES"
-            echo "" >> "$TEMP_FILES"
-        fi
-    done
-    
-    # Replace {{FILE_CONTENTS}} with content
-    if [ -s "$TEMP_FILES" ]; then
-        sed -i "/{{FILE_CONTENTS}}/r $TEMP_FILES" "$RESOLUTION_FILE"
-    fi
-    sed -i "s|{{FILE_CONTENTS}}||g" "$RESOLUTION_FILE"
-    rm -f "$TEMP_FILES"
-    
-    echo
-    echo -e "${YELLOW}=== AI RESOLUTION PROMPT GENERATED ===${NC}"
-    echo -e "${GREEN}An AI-friendly prompt has been generated at: ${BLUE}$RESOLUTION_FILE${NC}"
-    echo -e "${YELLOW}Copy this file to a new Claude instance to resolve problems automatically.${NC}"
-    echo
-}
-
-# Configure files for SonarQube mode
-GUIDELINES_FILE=".claude/CLAUDE_PRE_COMMIT_SONAR.md"
-PROMPT_TEMPLATE=".claude/CLAUDE_ANALYSIS_PROMPT_SONAR.md"
 
-
-# Check that the prompt template exists
-if [ ! -f "$PROMPT_TEMPLATE" ]; then
-    error "Prompt template not found: $PROMPT_TEMPLATE"
-    error "Claude configuration files appear to be incomplete."
-    error "Please reinstall claude-git-hooks by running:"
-    error "  claude-hooks install --force"
-    exit 1
-fi
-# Function to clean temporary files
-cleanup() {
-    rm -rf "$TEMP_DIR"
-}
-
-# Configure cleanup on exit
-trap cleanup EXIT
-
-# Create temporary directory
-mkdir -p "$TEMP_DIR"
-
-# Check if Claude CLI is installed (only for code analysis)
-if ! command -v "$CLAUDE_CLI" &> /dev/null; then
-    error "Claude CLI is not installed or not found in PATH"
-    error "Install Claude CLI from: https://github.com/anthropics/claude-cli"
-    exit 1
-fi
-
-# Now check if there are Java files to analyze
-JAVA_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(java|xml|properties|yml|yaml)$' || true)
-
-if [ -z "$JAVA_FILES" ]; then
-    log "No Java/configuration files to review"
-    exit 0
-fi
-
-# Check if the guidelines file exists
-if [ ! -f "$GUIDELINES_FILE" ]; then
-    error "Guidelines file not found: $GUIDELINES_FILE"
-    error "Please reinstall claude-git-hooks by running:"
-    error "  claude-hooks install --force"
-    exit 1
-fi
-
-log "Java/config files to review: $(echo "$JAVA_FILES" | wc -l)"
-
-# Function to filter content with SKIP-ANALYSIS
-filter_skip_analysis() {
-    local file_content="$1"
-    local filtered_content=""
-    local skip_next_line=false
-    local inside_skip_block=false
-    
-    while IFS= read -r line; do
-        # Detect SKIP-ANALYSIS for single line
-        if echo "$line" | grep -q "// SKIP-ANALYSIS"; then
-            skip_next_line=true
-            continue
-        fi
-        
-        # Detect start/end of SKIP_ANALYSIS_BLOCK
-        if echo "$line" | grep -q "// SKIP_ANALYSIS_BLOCK"; then
-            if [ "$inside_skip_block" = true ]; then
-                # End of block
-                inside_skip_block=false
-            else
-                # Start of block
-                inside_skip_block=true
-            fi
-            continue
-        fi
-        
-        # If we're inside a block, skip the line
-        if [ "$inside_skip_block" = true ]; then
-            continue
-        fi
-        
-        # If we should skip the next line (single comment)
-        if [ "$skip_next_line" = true ]; then
-            skip_next_line=false
-            continue
-        fi
-        
-        # Add line to filtered content
-        filtered_content="${filtered_content}${line}"$'\n'
-    done <<< "$file_content"
-    
-    echo "$filtered_content"
+    return 1
 }
 
-# Build the prompt for code analysis
-PROMPT_FILE="$TEMP_DIR/code_review_prompt.txt"
-
-# Copy the prompt template
-cat "$PROMPT_TEMPLATE" > "$PROMPT_FILE"
-
-# Add the guidelines
-echo "=== EVALUATION GUIDELINES ===" >> "$PROMPT_FILE"
-cat "$GUIDELINES_FILE" >> "$PROMPT_FILE"
-echo -e "\n\n=== CHANGES TO REVIEW ===\n" >> "$PROMPT_FILE"
-
-# Process each Java file
-FILE_COUNT=0
-for FILE in $JAVA_FILES; do
-    if [ -f "$FILE" ]; then
-        FILE_SIZE=$(stat -c%s "$FILE" 2>/dev/null || stat -f%z "$FILE" 2>/dev/null || echo "0")
-        
-        if [ "$FILE_SIZE" -gt "$MAX_FILE_SIZE" ]; then
-            warning "File $FILE too large ($FILE_SIZE bytes), skipping..."
-            continue
-        fi
-        
-        echo -e "\n--- Archivo: $FILE ---" >> "$PROMPT_FILE"
-        
-        # Get the diff and filter it
-        DIFF_CONTENT=$(git diff --cached "$FILE" 2>/dev/null || echo "Could not get diff")
-        FILTERED_DIFF=$(filter_skip_analysis "$DIFF_CONTENT")
-        
-        # Show the filtered diff of the file
-        echo -e "\nDiff:" >> "$PROMPT_FILE"
-        echo "$FILTERED_DIFF" >> "$PROMPT_FILE"
-        
-        # If it's a new file, show complete filtered content
-        if git diff --cached --name-status | grep "^A.*$FILE" > /dev/null; then
-            echo -e "\nComplete content (new file):" >> "$PROMPT_FILE"
-            FILE_CONTENT=$(git show ":$FILE" 2>/dev/null || cat "$FILE")
-            FILTERED_CONTENT=$(filter_skip_analysis "$FILE_CONTENT")
-            echo "$FILTERED_CONTENT" >> "$PROMPT_FILE"
-        fi
-        
-        FILE_COUNT=$((FILE_COUNT + 1))
-    fi
-done
-
-if [ "$FILE_COUNT" -eq 0 ]; then
-    log "No valid files found to review"
-    exit 0
-fi
-
-if [ "$FILE_COUNT" -gt 10 ]; then
-    warning "Too many files to review ($FILE_COUNT)"
-    warning "Consider splitting the commit into smaller parts"
-    exit 0
-fi
-
-log "Sending $FILE_COUNT files for review with Claude..."
-
-# Send to Claude and capture response
-RESPONSE_FILE="$TEMP_DIR/code_review_response.txt"
-
-# Execute Claude CLI and capture the response
-if $CLAUDE_CLI < "$PROMPT_FILE" > "$RESPONSE_FILE" 2>&1; then
-    # Extract the JSON from the response
-    JSON_RESPONSE=$(sed -n '/^{/,/^}/p' "$RESPONSE_FILE" | head -n 1000)
-    
-    if [ -z "$JSON_RESPONSE" ]; then
-        error "Did not receive a valid JSON response from Claude"
-        error "Complete response:"
-        cat "$RESPONSE_FILE"
-        exit 1
-    fi
-    
-    # Save JSON for debug if activated
-    if [ -n "$DEBUG" ]; then
-        echo "$JSON_RESPONSE" > ./debug-claude-response.json
-        log "Response saved to debug-claude-response.json"
-    fi
-    
-    # Parse the response using jq
-    APPROVED=$(echo "$JSON_RESPONSE" | jq -r '.approved // false')
-    SCORE=$(echo "$JSON_RESPONSE" | jq -r '.score // 0')
-    RECOMMENDATIONS=$(echo "$JSON_RESPONSE" | jq -r '.recommendations[]?' 2>/dev/null | sed '/^$/d')
-    
-    # Parse blockingIssues as objects and extract descriptions
-    BLOCKING_ISSUES=""
-    BLOCKING_COUNT=$(echo "$JSON_RESPONSE" | jq '.blockingIssues | length' 2>/dev/null || echo "0")
-    
-    if [ "$BLOCKING_COUNT" -gt 0 ]; then
-        BLOCKING_ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.blockingIssues[].description' 2>/dev/null | sed '/^$/d')
-    fi
-    
-    # Always use SonarQube mode (as per v1.4.1)
-    QUALITY_GATE=$(echo "$JSON_RESPONSE" | jq -r '.QUALITY_GATE // ""' 2>/dev/null)
-
-    # Show SonarQube style results
-    echo
-    echo "╔════════════════════════════════════════════════════════════════════╗"
-    echo "║                     CODE QUALITY ANALYSIS                           ║"
-    echo "╚════════════════════════════════════════════════════════════════════╝"
-    echo
-
-    # Quality Gate Status
-    if [ "$QUALITY_GATE" = "PASSED" ]; then
-        echo -e "${GREEN}✓ Quality Gate: PASSED${NC}"
-    else
-        echo -e "${RED}✗ Quality Gate: FAILED${NC}"
-    fi
-    echo
-
-    # Metrics
-    METRICS=$(echo "$JSON_RESPONSE" | jq -r '.metrics // {}' 2>/dev/null)
-    if [ "$METRICS" != "{}" ] && [ "$METRICS" != "null" ]; then
-        echo "📊 METRICS"
-        echo "├─ Reliability: $(echo "$METRICS" | jq -r '.reliability // "?"' 2>/dev/null)"
-        echo "├─ Security: $(echo "$METRICS" | jq -r '.security // "?"' 2>/dev/null)"
-        echo "├─ Maintainability: $(echo "$METRICS" | jq -r '.maintainability // "?"' 2>/dev/null)"
-        echo "├─ Coverage: $(echo "$METRICS" | jq -r '.coverage // "?"' 2>/dev/null)%"
-        echo "├─ Duplications: $(echo "$METRICS" | jq -r '.duplications // "?"' 2>/dev/null)%"
-        echo "└─ Complexity: $(echo "$METRICS" | jq -r '.complexity // "?"' 2>/dev/null)"
-        echo
-    fi
-
-    # Issues Summary
-    ISSUES=$(echo "$JSON_RESPONSE" | jq -r '.issues // {}' 2>/dev/null)
-    if [ "$ISSUES" != "{}" ] && [ "$ISSUES" != "null" ]; then
-        echo "📋 ISSUES SUMMARY"
-        BLOCKER=$(echo "$ISSUES" | jq -r '.blocker // 0' 2>/dev/null)
-        CRITICAL=$(echo "$ISSUES" | jq -r '.critical // 0' 2>/dev/null)
-        MAJOR=$(echo "$ISSUES" | jq -r '.major // 0' 2>/dev/null)
-        MINOR=$(echo "$ISSUES" | jq -r '.minor // 0' 2>/dev/null)
-        INFO=$(echo "$ISSUES" | jq -r '.info // 0' 2>/dev/null)
-        TOTAL=$((BLOCKER + CRITICAL + MAJOR + MINOR + INFO))
-
-        echo "Total: $TOTAL issues found"
-        [ "$BLOCKER" -gt 0 ] && echo -e "  ${RED}🔴 Blocker: $BLOCKER${NC}"
-        [ "$CRITICAL" -gt 0 ] && echo -e "  ${RED}🟠 Critical: $CRITICAL${NC}"
-        [ "$MAJOR" -gt 0 ] && echo -e "  ${YELLOW}🟡 Major: $MAJOR${NC}"
-        [ "$MINOR" -gt 0 ] && echo "  🔵 Minor: $MINOR"
-        [ "$INFO" -gt 0 ] && echo "  ⚪ Info: $INFO"
-        echo
-    fi
-
-    # Detailed Issues
-    DETAILS_COUNT=$(echo "$JSON_RESPONSE" | jq -r '.details | length' 2>/dev/null)
-    if [ "$DETAILS_COUNT" -gt 0 ] 2>/dev/null; then
-        echo "🔍 DETAILED ISSUES"
-        echo "$JSON_RESPONSE" | jq -r '.details[]? |
-            "[\(.severity)] \(.type) in \(.file):\(.line // "?")\n   \(.message)\n"' 2>/dev/null
-    fi
-
-    # Security Hotspots
-    HOTSPOTS=$(echo "$JSON_RESPONSE" | jq -r '.securityHotspots // 0' 2>/dev/null)
-    if [ "$HOTSPOTS" -gt 0 ] 2>/dev/null; then
-        echo "🔥 SECURITY HOTSPOTS: $HOTSPOTS found"
-        echo "   Review security-sensitive code carefully"
-        echo
-    fi
-
-    # Check if commit should be blocked
-    if [ "$QUALITY_GATE" = "FAILED" ] || [ "$APPROVED" = "false" ]; then
-        echo
-        error "❌ Commit blocked due to quality gate failure"
-
-        # Show blocking issues if they exist
-        if [ -n "$BLOCKING_ISSUES" ] && [ "$BLOCKING_ISSUES" != "null" ]; then
-            echo
-            echo "=== CRITICAL ISSUES ==="
-            echo "$BLOCKING_ISSUES" | sed 's/^/- /'
-        fi
-
-        # Generate AI-friendly resolution prompt if there are blocking issues
-        if [ "$BLOCKING_COUNT" -gt 0 ]; then
-            generate_resolution_prompt
-        fi
-
-        exit 1
-    fi
+# Find the Node.js script
+NODE_HOOK=$(find_hook_script)
 
-    echo
-    log "✅ Code analysis completed. Quality gate passed."
-    
-else
-    error "Error executing Claude CLI"
-    error "Check that Claude CLI is configured correctly"
-    cat "$RESPONSE_FILE"
+if [ -z "$NODE_HOOK" ]; then
+    echo -e "${RED}Error: Could not find pre-commit.js${NC}" >&2
+    echo "Claude Git Hooks may not be properly installed." >&2
+    echo "Try running: claude-hooks install --force" >&2
     exit 1
 fi
 
-exit 0
+# Execute the Node.js script
+# Why: Pass all arguments ($@) to support future hook extensions
+exec node "$NODE_HOOK" "$@"