Automated code review using local LLMs

code_review.sh

#!/bin/bash

# Define variables
REPO_PATH=""
PR_NUMBER=""
OLLAMA_API_URL="http://localhost:11434/api/generate"
OUTPUT_FILE="code_review_output.md"
MODEL="llama3.1:8b"
MAX_CONTEXT_LINES=20000

command_exists() {
    command -v "$1" >/dev/null 2>&1
}

for cmd in gh jq curl git tree; do
    if ! command_exists "$cmd"; then
        echo "Error: $cmd is not installed. Please install it and try again."
        exit 1
    fi
done

encode_string() {
    jq -rn --arg x "$1" '$x|@json'
}

get_codebase_context() {
    local pr_files
    pr_files=$(gh pr view "$PR_NUMBER" --json files --jq '.files[].path')
    local context=""
    local total_lines=0

    # Add high-level codebase structure
    context+="Codebase Structure:\n"
    context+=$(tree -L 2 -d --charset=ascii | head -n 50)
    context+="\n\n"

    # Process each changed file
    for file in $pr_files; do
        if [ -f "$file" ]; then
            # Current version of the file
            local current_content
            current_content=$(git show "HEAD:$file" 2>/dev/null)
            
            local previous_commit
            previous_commit=$(git log -n 1 --pretty=format:%H -- "$file")
            local previous_content
            previous_content=$(git show "$previous_commit^:$file" 2>/dev/null)
            
            context+="File: $file\n\n"
            context+="Current version:\n\`\`\`\n$current_content\n\`\`\`\n\n"
            context+="Previous version:\n\`\`\`\n$previous_content\n\`\`\`\n\n"
            
            total_lines=$((total_lines + $(echo "$current_content" | wc -l) + $(echo "$previous_content" | wc -l)))
            
            if [ $total_lines -ge $MAX_CONTEXT_LINES ]; then
                context+="...(truncated due to length)...\n"
                break
            fi
        fi
    done

    echo -e "$context"
}


if [ -z "$REPO_PATH" ]; then
    echo "Error: Not in a git repository. Please run this script from within a git repository."
    exit 1
fi

cd "$REPO_PATH" || { echo "Error: Unable to change to repository root."; exit 1; }

read -rp "Enter the PR number: " PR_NUMBER

if ! [[ "$PR_NUMBER" =~ ^[0-9]+$ ]]; then
    echo "Error: Invalid PR number. Please enter a valid number."
    exit 1
fi

echo "Fetching PR diff..."
PR_DIFF=$(gh pr diff "$PR_NUMBER") || { echo "Error: Unable to fetch PR diff. Make sure you have access to this PR."; exit 1; }

echo "Gathering codebase context..."
CODEBASE_CONTEXT=$(get_codebase_context)

PROMPT=$(cat <<EOT
You are an expert Python developer and software professional with extensive experience in code review and a deep understanding of Python best practices, design patterns, and modern development standards. Your task is to thoroughly analyze the following Pull Request (PR) diff in the context of the existing codebase and provide a comprehensive, professional code review.

Review Guidelines:
1. Code Quality and Readability:
   - Assess adherence to PEP 8 style guide
   - Evaluate naming conventions for clarity and consistency
   - Check for code complexity and suggest simplifications
   - Analyze docstrings and comments for completeness and clarity

2. Potential Bugs and Issues:
   - Identify logical errors or edge cases not handled
   - Spot potential performance bottlenecks
   - Flag any security vulnerabilities
   - Highlight possible race conditions in concurrent code
   - Identify Code smells

3. Best Practices and Modern Python Standards:
   - Suggest use of appropriate Python 3.x features
   - Recommend relevant design patterns or idioms
   - Advise on proper exception handling
   - Propose use of type hints and assess current usage

4. Code Structure and Architecture:
   - Evaluate function/class design and responsibilities
   - Assess modularity and potential for code reuse
   - Check for adherence to SOLID principles
   - Suggest improvements in overall code organization

5. Testing and Maintainability:
   - Analyze test coverage and quality
   - Suggest additional test scenarios if necessary
   - Assess code maintainability and scalability
   - Recommend documentation improvements

6. Dependencies and Compatibility:
   - Review any new dependencies introduced
   - Check for deprecated method usage
   - Assess compatibility with different Python versions if applicable

7. Integration with Existing Codebase:
   - Evaluate how well the changes fit with the existing architecture
   - Check for consistency with established patterns in the project
   - Identify any potential conflicts or redundancies

8. Performance and Efficiency:
   - Analyze algorithmic efficiency
   - Suggest optimizations where appropriate
   - Review database queries or API calls for efficiency

9. Code Duplication and Reusability:
   - Identify any code duplication
   - Suggest abstractions to improve reusability

10. Overall Impact:
    - Assess the overall quality and impact of the changes
    - Provide a summary of key findings and recommendations
11. Additional Comments:
    - Include any other relevant observations or suggestions

Format your review as follows:
1. Start with a brief summary of the PR, highlighting its purpose and overall impact.
2. Provide a section for each of the above areas, clearly labeling them.
3. Within each section, list your observations, using bullet points for clarity.
4. For each significant issue or suggestion, provide:
   - A brief explanation of the issue
   - The relevant code snippet (if applicable)
   - Your recommendation for improvement
   - If possible, a code example of the suggested change
5. Use Markdown formatting for readability, including appropriate headers, code blocks with syntax highlighting, and emphasis where needed.
6. Conclude with an overall assessment and your recommendation (approve, request changes, etc.).

Codebase Context:
$CODEBASE_CONTEXT

PR Diff:
\`\`\`diff
$PR_DIFF
\`\`\`

Please provide your comprehensive code review based on the above guidelines:
EOT
)

ENCODED_PROMPT=$(encode_string "$PROMPT")

echo "Generating code review..."
RESPONSE=$(curl -s -X POST "$OLLAMA_API_URL" \
-H "Content-Type: application/json" \
-d "{
    \"model\": \"$MODEL\",
    \"prompt\": $ENCODED_PROMPT,
    \"stream\": false
}")

if [ $? -ne 0 ]; then
    echo "Error: Failed to connect to Ollama API. Make sure Ollama is running and the API is accessible."
    exit 1
fi

REVIEW_FEEDBACK=$(echo "$RESPONSE" | jq -r '.response')

# Check if we got a valid response
if [ -z "$REVIEW_FEEDBACK" ]; then
    echo "Error: Received empty response from Ollama API."
    exit 1
fi

{
    echo "# Code Review for PR #$PR_NUMBER"
    echo "## Review Feedback"
    echo "$REVIEW_FEEDBACK"
} > "$OUTPUT_FILE"

echo "Code review feedback saved to $OUTPUT_FILE"