Cosa fa

codereview invia il tuo codice a un LLM e restituisce una recensione strutturata e codificata a colori direttamente nel tuo terminale — con valutazioni di gravità, riferimenti alle righe e suggerimenti concreti per le correzioni.

Niente browser. Nessuna PR richiesta. Nessuna attesa per i colleghi. Basta:

codereview app.py

Rilevare vulnerabilità di sicurezza reali — valutazione 2/10

Recensire il proprio codice sorgente — valutazione 9/10

Perché

• Sviluppatori solitari — ottieni un secondo paio di occhi senza aspettare nessuno
• Controllo pre-commit — rileva bug prima che arrivino nella PR
• Strumento di apprendimento — capisci perché il codice è problematico, non solo che lo è
• Integrazione CI — aggiungi alla tua pipeline per revisioni automatizzate
• Gratuito — funziona con Groq (livello gratuito, senza carta di credito) o completamente offline con Ollama

Cosa rileva

Installa

Da sorgente (consigliato)

git clone https://github.com/jaydendancer12/ai-code-review.git
cd ai-code-review
./install.sh

Oppure manualmente:

git clone https://github.com/jaydendancer12/ai-code-review.git
cd ai-code-review
pip install -e .

Tutte le dipendenze (rich, requests) si installano automaticamente. Nessun'altra configurazione necessaria.

Avvio rapido (gratuito, 60 secondi)

codereview ha bisogno di un LLM per analizzare il tuo codice. L'opzione gratuita più veloce è Groq — niente carta di credito, niente prova, solo gratuito.

Passo 1 — Ottieni una chiave API gratuita

1. Vai su console.groq.com
2. Registrati con Google o GitHub (richiede 30 secondi)
3. Clicca su API Keys poi Create API Key
4. Copia la chiave (inizia con gsk_)

Passo 2 — Imposta la tua chiave

export GROQ_API_KEY="gsk_your_key_here"

Per renderlo permanente (in modo da non doverlo impostare ad ogni sessione del terminale):

# Per zsh (predefinito su Mac)
echo 'export GROQ_API_KEY="gsk_your_key_here"' >> ~/.zshrc
source ~/.zshrc

# Per bash (predefinito su Linux)
echo 'export GROQ_API_KEY="gsk_your_key_here"' >> ~/.bashrc
source ~/.bashrc

Passo 3 — Inizializza

codereview --init groq

Passo 4 — Revisiona il codice

codereview yourfile.py

Ecco fatto. Stai eseguendo revisioni del codice con AI.

Prima volta che esegui? Basta digitare codereview senza argomenti e ti guiderà attraverso l'intera configurazione.

Utilizzo

Revisiona un file

codereview app.py

Revisiona più file

codereview src/auth.py src/db.py src/api.py

Revisiona le modifiche staged di git (pre-commit)

git add .
codereview --staged

Revisiona gli ultimi N commit

codereview --last 3

Revisiona il diff tra branch

codereview --diff origin/main

Invia codice da stdin

cat suspicious_code.py | codereview --stdin

Usa un modello specifico

codereview app.py --model gpt-4

Usa un provider specifico per una revisione

codereview app.py --provider ollama

Mostra le istruzioni di configurazione

codereview --setup

Provider

codereview funziona con qualsiasi API compatibile con OpenAI. Scegli ciò che funziona per te:

⚡ Groq (consigliato — gratuito, veloce)

export GROQ_API_KEY="gsk_your_key_here"
codereview --init groq

• Costo: Livello gratuito, nessuna carta di credito richiesta
• Velocità: Inferenza più veloce disponibile
• Modello: Llama 3.3 70B
• Ottieni una chiave: console.groq.com

🏠 Ollama (gratuito, completamente offline)

# 1. Installa Ollama
# Mac: Scarica da https://ollama.com
# Linux: curl -fsSL https://ollama.com/install.sh | sh

# 2. Scarica un modello
ollama pull llama3

# 3. Avvia il server
ollama serve

# 4. Inizializza (nessuna chiave API richiesta)
codereview --init ollama

• Costo: Gratuito per sempre
• Velocità: Dipende dal tuo hardware
• Privacy: Il codice non lascia mai la tua macchina
• Modello: Qualsiasi modello supportato da Ollama

🧠 OpenAI

export OPENAI_API_KEY="sk-..."
codereview --init openai

• Costo: Paga per token
• Modello: GPT-3.5 Turbo (predefinito), GPT-4 con --model gpt-4
• Ottieni una chiave: platform.openai.com

🔮 Anthropic

export ANTHROPIC_API_KEY="sk-ant-..."
codereview --init anthropic

• Costo: Paga per token
• Modello: Claude 3 Haiku (predefinito)
• Ottieni una chiave: console.anthropic.com

Configurazione

La configurazione è memorizzata in ~/.codereview/config.json:

{
  "provider": "groq",
  "model": "llama-3.3-70b-versatile",
  "base_url": "https://api.groq.com/openai/v1",
  "max_tokens": 2048,
  "temperature": 0.2
}

Le chiavi API non sono mai memorizzate nel file di configurazione. Vengono lette solo dalle variabili d'ambiente.

Sovrascrivi qualsiasi cosa tramite variabili d'ambiente

export CODEREVIEW_API_KEY="any-key"     # Sovrascrittura universale
export CODEREVIEW_MODEL="gpt-4"         # Sovrascrittura modello

Sovrascrivi tramite flag CLI

codereview app.py --model gpt-4 --provider openai

Come funziona

Tuoi Codice  -->  CLI codereview  -->  API LLM  -->  Output Strutturato Terminale
(file/diff)     (costruttore prompt)    (qualsiasi provider)  (risultati codificati a colori)

1. Input — codereview legge il tuo file, git diff, modifiche staged o stdin
2. Prompt — Costruisce un prompt di revisione mirato con regole rigorose per prevenire problemi allucinati
3. LLM — Invia a qualsiasi API compatibile con OpenAI (Groq, OpenAI, Anthropic, Ollama)
4. Analisi — Estrae JSON strutturato dalla risposta del LLM
5. Visualizzazione — Mostra risultati codificati a colori e ordinati per gravità nel tuo terminale

Cosa lo rende diverso da ChatGPT

• Output strutturato — Valutazioni di gravità, riferimenti ai file, suggerimenti concreti
• Niente allucinazioni — L'ingegneria dei prompt assicura che il LLM segnali solo problemi che può vedere nel tuo codice
• Funziona sui diff — Revisiona solo ciò che è cambiato, non l'intero codebase
• Un comando — Niente copia-incolla in un browser
• Capacità offline — Esegui con Ollama, il tuo codice non lascia mai la tua macchina
• Gratuito — Nessun abbonamento richiesto

Esempi

Audit di sicurezza su un file sospetto

$ codereview api/auth.py

Punteggio: 3/10

🔴 CRITICO — Segreto JWT hardcoded
   La chiave segreta è hardcoded alla riga 12.
   Suggerimento: Usa variabile d'ambiente: os.environ["JWT_SECRET"]

🔴 CRITICO — Nessun hashing delle password
   Le password sono memorizzate in chiaro alla riga 34.
   Suggerimento: Usa bcrypt: bcrypt.hashpw(password, bcrypt.gensalt())

🟡 AVVISO — Il token non scade mai
   I token JWT non hanno scadenza impostata.
   Suggerimento: Aggiungi rivendicazione exp con timedelta

Revisione pre-commit delle modifiche staged

$ git add .
$ codereview --staged

Punteggio: 8/10

🔵 INFO — Considera l'aggiunta di gestione errori
   Il nuovo endpoint API non cattura ConnectionError.
   Suggerimento: Avvolgi in try/except con logica di retry.

Revisione degli ultimi 3 commit prima del push

$ codereview --last 3

Punteggio: 9/10

⚪ STILE — Nomenclatura incoerente
   Mix di snake_case e camelCase in utils.py
   Suggerimento: Mantieni snake_case come da PEP 8.

Utilizzo in CI/CD

Aggiungi al tuo workflow GitHub Actions:

name: Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-python@v5
        with:
          python-version: "3.10"
      - run: pip install ai-code-review
      - run: codereview --diff origin/main
        env:
          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}

Struttura del progetto

ai-code-review/
├── codereview/
│   ├── __init__.py          # Versione
│   ├── cli.py               # Interfaccia a riga di comando + configurazione primo avvio
│   ├── reviewer.py          # Chiamate API LLM + analisi risposta
│   ├── formatter.py         # Formattazione output terminale ricco
│   ├── git_utils.py         # Utilità di estrazione diff/file Git
│   └── config.py            # Gestione configurazione + gestione chiavi API
├── tests/
│   ├── test_reviewer.py     # Test analisi revisione
│   └── test_git_utils.py    # Test utilità Git
├── setup.py
├── pyproject.toml
├── LICENSE
└── README.md

Risoluzione dei problemi

"Nessuna chiave API trovata"

Non hai impostato la chiave API. L'opzione gratuita più veloce:

# 1. Ottieni una chiave gratuita su https://console.groq.com
# 2. Imposta:
export GROQ_API_KEY="gsk_your_key_here"
codereview --init groq

"Errore API 403: codice errore 1010"

Il tuo client HTTP è bloccato da Cloudflare. Assicurati di essere aggiornato:

git pull
pip install -e .

"Modello dismesso"

Il modello è stato deprecato. Reinizializza per ottenere il modello più recente:

codereview --init groq

"Connessione rifiutata" (Ollama)

Il server Ollama non è in esecuzione:

ollama serve

Poi riprova in un nuovo terminale.

"Nessun modulo chiamato rich" o "Nessun modulo chiamato requests"

Le dipendenze non sono state installate. Esegui:

pip install rich requests

Oppure reinstalla:

pip install -e .

Comando non trovato: codereview

L'installazione non lo ha aggiunto al tuo PATH. Usalo direttamente:

python3 -m codereview.cli yourfile.py

Oppure crea un alias:

echo 'alias codereview="python3 -m codereview.cli"' >> ~/.zshrc
source ~/.zshrc

Contribuisci

PR benvenute! Questo progetto è mantenuto attivamente.

Configura ambiente di sviluppo

git clone https://github.com/jaydendancer12/ai-code-review.git
cd ai-code-review
pip install -e .
pip install pytest

Esegui test

pytest -v

Stile del codice

• Usa type hint su tutte le funzioni
• Scrivi docstring per tutte le funzioni pubbliche
• Segui PEP 8
• Aggiungi test per nuove funzionalità

Linee guida PR

1. Fai un fork del repo
2. Crea un branch per la funzionalità: git checkout -b feat/mia-funzionalità
3. Apporta modifiche e aggiungi test
4. Esegui pytest per verificare
5. Invia una PR con una descrizione chiara

Roadmap

• Scansione directory — codereview src/ revisiona tutti i file ricorsivamente
• Profili di configurazione — passa da un provider all'altro con codereview --profile lavoro
• Formati di output — JSON, Markdown, SARIF per integrazione CI
• Git hooks — revisione automatica su git commit
• Estensione VS Code — revisiona dal tuo editor
• Cronologia delle revisioni — monitora i miglioramenti nel tempo
• Regole personalizzate — definisci i tuoi criteri di revisione
• Supporto multilingua — prompt di revisione specifici per linguaggio

Licenza

MIT — vedi LICENSE