Step-by-Step: Building a Self-Hosting AI Code Review Pipeline with Gitea 1.22 and LocalAI 2.0

version: "3.8"

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: gitea
      POSTGRES_PASSWORD: gitea_secure_password_123
      POSTGRES_DB: gitea
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U gitea"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  gitea:
    image: gitea/gitea:1.22.0-rootless
    environment:
      GITEA__database__DB_TYPE: postgres
      GITEA__database__HOST: postgres:5432
      GITEA__database__NAME: gitea
      GITEA__database__USER: gitea
      GITEA__database__PASSWD: gitea_secure_password_123
      GITEA__server__ROOT_URL: http://gitea:3000/
      GITEA__server__DOMAIN: gitea
      GITEA__server__HTTP_PORT: 3000
      GITEA__webhook__QUEUE_LENGTH: 1000
      GITEA__webhook__BATCH_TIMEOUT: 10s  # Batch webhooks for 10s to reduce middleware load
    ports:
      - "3000:3000"
      - "2222:2222"
    volumes:
      - gitea_data:/var/lib/gitea
      - gitea_config:/etc/gitea
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  localai:
    image: localai/localai:v2.0.0
    environment:
      LOCALAI_MODELS_PATH: /models
      LOCALAI_API_KEY: ""
      LOCALAI_COREML_ENABLED: "false"
      LOCALAI_CUDA_ENABLED: "false"
    ports:
      - "8080:8080"
    volumes:
      - localai_models:/models
      - localai_data:/tmp/localai
    command: ["--models-path", "/models", "--context-size", "4096", "--threads", "4"]  # 4 threads for consumer hardware, 4096 context window fits most PR diffs
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
    restart: unless-stopped

  review-middleware:
    build: ./middleware  # Custom Go middleware we'll write in Step 3
    environment:
      GITEA_API_TOKEN: "your_gitea_token_here"
      GITEA_BASE_URL: "http://gitea:3000"
      LOCALAI_BASE_URL: "http://localai:8080"
      LOCALAI_MODEL: "llama3.1-8b-q4_0"
      REDIS_ADDR: "redis:6379"
      REDIS_PASSWORD: ""
      REDIS_DB: 0
    ports:
      - "9090:9090"
    depends_on:
      - gitea
      - localai
      - redis
    restart: unless-stopped

volumes:
  postgres_data:
  gitea_data:
  gitea_config:
  localai_models:
  localai_data:
  redis_data:

#!/bin/bash
set -euo pipefail  # Exit on error, undefined vars, pipe fail

MODEL_NAME="llama3.1-8b-q4_0"
MODELS_DIR="./models"
LOCALAI_CONTAINER="selfhosting-ai-review-localai-1"  # Match docker-compose container name

# Check if model already exists to avoid re-download
if [ -f "${MODELS_DIR}/${MODEL_NAME}.gguf" ]; then
    echo "Model ${MODEL_NAME} already exists, skipping download."
    exit 0
fi

# Create models directory if it doesn't exist
mkdir -p "${MODELS_DIR}"
chmod 777 "${MODELS_DIR}"  # LocalAI runs as non-root, need write access

# Download quantized GGUF model from Hugging Face
wget -q --show-progress \
    "https://huggingface.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF/resolve/main/${MODEL_NAME}.gguf" \
    -O "${MODELS_DIR}/${MODEL_NAME}.gguf" \
    || { echo "Failed to download model"; exit 1; }

# Verify download integrity with SHA256
EXPECTED_SHA="a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456"  # Replace with actual SHA from Hugging Face
DOWNLOADED_SHA=$(sha256sum "${MODELS_DIR}/${MODEL_NAME}.gguf" | awk '{print $1}')

if [ "${DOWNLOADED_SHA}" != "${EXPECTED_SHA}" ]; then
    echo "SHA256 mismatch! Expected ${EXPECTED_SHA}, got ${DOWNLOADED_SHA}"
    rm -f "${MODELS_DIR}/${MODEL_NAME}.gguf"
    exit 1
fi

# Create LocalAI model config file
echo "Creating LocalAI model configuration..."
cat > "${MODELS_DIR}/${MODEL_NAME}.yaml" << EOF
name: ${MODEL_NAME}
parameters:
  model: ${MODEL_NAME}.gguf
  context_size: 4096
  threads: 4
  f16: false  # Use quantized weights for lower memory usage
backend: llama.cpp
EOF

# Copy config to LocalAI container if running
if docker ps --format '{{.Names}}' | grep -q "${LOCALAI_CONTAINER}"; then
    echo "Copying model to LocalAI container..."
    docker cp "${MODELS_DIR}/${MODEL_NAME}.gguf" "${LOCALAI_CONTAINER}:/models/"
    docker cp "${MODELS_DIR}/${MODEL_NAME}.yaml" "${LOCALAI_CONTAINER}:/models/"
    echo "Restarting LocalAI to load model..."
    docker restart "${LOCALAI_CONTAINER}"
else
    echo "LocalAI container not running, copy model files manually to /models directory"
fi

echo "Model setup complete. LocalAI will load ${MODEL_NAME} on next restart."

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strings"
    "time"

    "github.com/go-redis/redis/v8"
    "github.com/google/uuid"
    "github.com/xanzy/go-gitea-client/gitea"
)

// Config holds all environment variables for the middleware
type Config struct {
    GiteaBaseURL   string
    GiteaAPIToken  string
    LocalAIBaseURL string
    LocalAIModel   string
    RedisAddr      string
    RedisPassword  string
    RedisDB        int
    ListenAddr     string
}

// WebhookPayload matches Gitea's pull request webhook payload
type WebhookPayload struct {
    Action      string `json:"action"`
    Number      int    `json:"number"`
    PullRequest struct {
        HTMLURL string `json:"html_url"`
        DiffURL string `json:"diff_url"`
        Title   string `json:"title"`
        Head    struct {
            Sha string `json:"sha"`
        } `json:"head"`
    } `json:"pull_request"`
    Repository struct {
        FullName string `json:"full_name"`
    } `json:"repository"`
}

// ReviewRequest matches LocalAI's chat completion request format
type ReviewRequest struct {
    Model    string    `json:"model"`
    Messages []Message `json:"messages"`
    Stream   bool      `json:"stream"`
}

// Message represents a chat message for LocalAI
type Message struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

// ReviewResponse matches LocalAI's chat completion response
type ReviewResponse struct {
    Choices []struct {
        Message struct {
            Content string `json:"content"`
        } `json:"message"`
    } `json:"choices"`
}

var (
    ctx          = context.Background()
    cfg          Config
    rdb          *redis.Client
    giteaClient  *gitea.Client
)

func main() {
    // Load configuration from environment variables
    loadConfig()

    // Initialize Redis client for webhook queuing
    rdb = redis.NewClient(&redis.Options{
        Addr:     cfg.RedisAddr,
        Password: cfg.RedisPassword,
        DB:       cfg.RedisDB,
    })
    if _, err := rdb.Ping(ctx).Result(); err != nil {
        log.Fatalf("Failed to connect to Redis: %v", err)
    }

    // Initialize Gitea client
    giteaClient, err := gitea.NewClient(cfg.GiteaBaseURL, gitea.SetToken(cfg.GiteaAPIToken))
    if err != nil {
        log.Fatalf("Failed to initialize Gitea client: %v", err)
    }

    // Register webhook handler
    http.HandleFunc("/webhook/gitea", giteaWebhookHandler)
    http.HandleFunc("/health", healthHandler)

    log.Printf("Starting review middleware on %s", cfg.ListenAddr)
    if err := http.ListenAndServe(cfg.ListenAddr, nil); err != nil {
        log.Fatalf("Failed to start HTTP server: %v", err)
    }
}

func loadConfig() {
    cfg = Config{
        GiteaBaseURL:   getEnv("GITEA_BASE_URL", "http://gitea:3000"),
        GiteaAPIToken:  getEnv("GITEA_API_TOKEN", ""),
        LocalAIBaseURL: getEnv("LOCALAI_BASE_URL", "http://localai:8080"),
        LocalAIModel:   getEnv("LOCALAI_MODEL", "llama3.1-8b-q4_0"),
        RedisAddr:      getEnv("REDIS_ADDR", "redis:6379"),
        RedisPassword:  getEnv("REDIS_PASSWORD", ""),
        RedisDB:        getEnvAsInt("REDIS_DB", 0),
        ListenAddr:     getEnv("LISTEN_ADDR", ":9090"),
    }

    if cfg.GiteaAPIToken == "" {
        log.Fatal("GITEA_API_TOKEN environment variable is required")
    }
}

func getEnv(key, defaultVal string) string {
    if val := os.Getenv(key); val != "" {
        return val
    }
    return defaultVal
}

func getEnvAsInt(key string, defaultVal int) int {
    val := os.Getenv(key)
    if val == "" {
        return defaultVal
    }
    var intVal int
    if _, err := fmt.Sscanf(val, "%d", &intVal); err != nil {
        log.Printf("Invalid integer for %s: %s, using default %d", key, val, defaultVal)
        return defaultVal
    }
    return intVal
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("OK"))
}

func giteaWebhookHandler(w http.ResponseWriter, r *http.Request) {
    // Only accept POST requests
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // Read request body
    body, err := io.ReadAll(r.Body)
    if err != nil {
        log.Printf("Failed to read request body: %v", err)
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    // Parse webhook payload
    var payload WebhookPayload
    if err := json.Unmarshal(body, &payload); err != nil {
        log.Printf("Failed to parse webhook payload: %v", err)
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }

    // Only process opened or synchronized PRs
    if payload.Action != "opened" && payload.Action != "synchronized" {
        log.Printf("Ignoring action %s for PR #%d", payload.Action, payload.Number)
        w.WriteHeader(http.StatusOK)
        return
    }

    // Queue review job to Redis to avoid blocking webhook
    jobID := uuid.New().String()
    jobData := map[string]interface{}{
        "job_id":     jobID,
        "repo":       payload.Repository.FullName,
        "pr_number":  payload.Number,
        "diff_url":   payload.PullRequest.DiffURL,
        "pr_sha":     payload.PullRequest.Head.Sha,
        "created_at": time.Now().Unix(),
    }
    jobJSON, _ := json.Marshal(jobData)
    if err := rdb.LPush(ctx, "review_jobs", jobJSON).Err(); err != nil {
        log.Printf("Failed to queue review job: %v", err)
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }

    log.Printf("Queued review job %s for PR #%d in %s", jobID, payload.Number, payload.Repository.FullName)
    w.WriteHeader(http.StatusOK)
    go processReviewJob(jobData)  // Process job asynchronously
}

func processReviewJob(jobData map[string]interface{}) {
    repo := jobData["repo"].(string)
    prNumber := int(jobData["pr_number"].(float64))
    diffURL := jobData["diff_url"].(string)
    prSHA := jobData["pr_sha"].(string)

    // Fetch PR diff from Gitea
    diff, err := fetchDiff(diffURL)
    if err != nil {
        log.Printf("Failed to fetch diff for PR #%d: %v", prNumber, err)
        return
    }

    // Generate review prompt
    prompt := generateReviewPrompt(diff, repo, prNumber)
    if len(prompt) == 0 {
        log.Printf("Empty prompt for PR #%d, skipping", prNumber)
        return
    }

    // Call LocalAI for review
    review, err := callLocalAI(prompt)
    if err != nil {
        log.Printf("Failed to get review from LocalAI for PR #%d: %v", prNumber, err)
        return
    }

    // Post review to Gitea PR
    if err := postReviewToGitea(repo, prNumber, prSHA, review); err != nil {
        log.Printf("Failed to post review to Gitea for PR #%d: %v", prNumber, err)
        return
    }

    log.Printf("Successfully posted review for PR #%d in %s", prNumber, repo)
}

func fetchDiff(diffURL string) (string, error) {
    // Use Gitea client to fetch diff (avoids exposing diff URL directly)
    // Note: This is a simplified implementation; refer to Gitea API docs for full diff fetch
    resp, err := giteaClient.GetPullRequestDiff(repo, prNumber, gitea.PullRequestDiffOptions{})
    if err != nil {
        return "", fmt.Errorf("failed to fetch diff via Gitea API: %v", err)
    }
    return resp, nil
}

func generateReviewPrompt(diff, repo string, prNumber int) string {
    return fmt.Sprintf(`You are a senior software engineer reviewing a pull request for repository %s, PR #%d.
Analyze the following diff and provide actionable, specific comments. Focus on:
1. Security vulnerabilities (SQL injection, XSS, insecure dependencies)
2. Performance issues (N+1 queries, unnecessary allocations)
3. Code style violations (per repository conventions)
4. Logic errors or edge cases

Diff:
%s

Format your response as a JSON array of comments, each with "path" (file path), "line" (line number), "body" (comment text). If no issues found, return empty array.`, repo, prNumber, diff)
}

func callLocalAI(prompt string) (string, error) {
    reqBody := ReviewRequest{
        Model: cfg.LocalAIModel,
        Messages: []Message{
            {Role: "system", Content: "You are a code review assistant that outputs valid JSON."},
            {Role: "user", Content: prompt},
        },
        Stream: false,
    }

    reqJSON, err := json.Marshal(reqBody)
    if err != nil {
        return "", fmt.Errorf("failed to marshal LocalAI request: %v", err)
    }

    resp, err := http.Post(fmt.Sprintf("%s/v1/chat/completions", cfg.LocalAIBaseURL), "application/json", bytes.NewBuffer(reqJSON))
    if err != nil {
        return "", fmt.Errorf("failed to call LocalAI: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        return "", fmt.Errorf("LocalAI returned status %d: %s", resp.StatusCode, body)
    }

    var reviewResp ReviewResponse
    if err := json.NewDecoder(resp.Body).Decode(&reviewResp); err != nil {
        return "", fmt.Errorf("failed to decode LocalAI response: %v", err)
    }

    if len(reviewResp.Choices) == 0 {
        return "", fmt.Errorf("no choices in LocalAI response")
    }

    return reviewResp.Choices[0].Message.Content, nil
}

func postReviewToGitea(repo string, prNumber int, prSHA string, review string) error {
    // Parse review JSON from LocalAI response
    var comments []map[string]string
    if err := json.Unmarshal([]byte(review), &comments); err != nil {
        // If not valid JSON, post as a general comment
        _, _, err := giteaClient.CreatePullRequestComment(repo, prNumber, gitea.CreatePullRequestCommentOption{
            Body: review,
            SHA:  prSHA,
        })
        return err
    }

    // Post each inline comment
    for _, comment := range comments {
        _, _, err := giteaClient.CreatePullRequestReviewComment(repo, prNumber, gitea.CreatePullRequestReviewCommentOption{
            Body: comment["body"],
            Path: comment["path"],
            Line: comment["line"],
            SHA:  prSHA,
        })
        if err != nil {
            log.Printf("Failed to post comment to PR #%d: %v", prNumber, err)
            continue
        }
    }
    return nil
}

# LocalAI model config for Q4_0 quantization
name: llama3.1-8b-q4_0
parameters:
  model: llama3.1-8b-q4_0.gguf
  context_size: 4096
  threads: 4  # Match number of CPU cores allocated to LocalAI
  f16: false
backend: llama.cpp

# Replace LPush with Redis Streams XAdd
func queueReviewJob(jobData map[string]interface{}) error {
    jobJSON, _ := json.Marshal(jobData)
    _, err := rdb.XAdd(ctx, &redis.XAddArgs{
        Stream: "review_jobs_stream",
        ID:     "*",  # Auto-generate ID
        Values: map[string]interface{}{"data": jobJSON},
    }).Result()
    return err
}

# Fetch static analysis results for Go PR diff
func fetchStaticAnalysis(repo, prSHA string) (string, error) {
    // Clone repo to temp dir, checkout PR SHA, run golangci-lint
    cmd := exec.Command("golangci-lint", "run", "--out-format", "json")
    cmd.Dir = "/tmp/repo-checkout"
    output, err := cmd.CombinedOutput()
    if err != nil && !bytes.Contains(output, []byte("issues found")) {
        return "", fmt.Errorf("static analysis failed: %v", err)
    }
    return string(output), nil
}

gitea-localai-review/
├── docker-compose.yml       # Base infrastructure definition (Step 1)
├── middleware/              # Go review middleware
│   ├── Dockerfile           # Middleware container definition
│   ├── go.mod               # Go module dependencies
│   ├── go.sum               # Dependency checksums
│   └── main.go              # Full middleware code (Step 3)
├── scripts/
│   └── download-model.sh    # Model download script (Step 2)
├── models/                  # LocalAI model configs and GGUF files
│   ├── llama3.1-8b-q4_0.gguf
│   └── llama3.1-8b-q4_0.yaml
├── gitea/
│   └── webhook-config.json  # Sample Gitea webhook configuration
└── README.md                # Setup instructions and benchmarks