12 - Claude Code CLI: Comandi Essenziali e Configurazione

# Installazione globale
npm install -g @anthropic-ai/claude-code

# Verifica installazione
claude --version

# Primo avvio e autenticazione
claude

# Aggiornamento alla versione più recente
npm update -g @anthropic-ai/claude-code

# macOS e Linux
curl -fsSL https://cli.anthropic.com/install.sh | sh

# Verifica che il binario sia nel PATH
which claude
# Output atteso: /usr/local/bin/claude

# Prima esecuzione
claude

# Aggiungere il tap ufficiale Anthropic
brew tap anthropics/claude-code

# Installazione
brew install claude-code

# Aggiornamento
brew upgrade claude-code

# Verifica versione
claude --version

# Passo 1: Installare WSL2 (se non già installato)
wsl --install

# Passo 2: Aprire il terminale WSL (Ubuntu)
wsl

# Passo 3: Installare Node.js nel WSL
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

# Passo 4: Installare Claude Code
npm install -g @anthropic-ai/claude-code

# Passo 5: Verificare
claude --version

# Alternativa: Installazione diretta da PowerShell
# (Richiede Node.js installato su Windows)
npm install -g @anthropic-ai/claude-code

# Metodo 1: Variabile d'ambiente (sessione corrente)
export ANTHROPIC_API_KEY="sk-ant-api03-xxxxx"

# Metodo 2: File .env nella root del progetto
echo 'ANTHROPIC_API_KEY=sk-ant-api03-xxxxx' >> .env

# Metodo 3: Configurazione permanente in .bashrc o .zshrc
echo 'export ANTHROPIC_API_KEY="sk-ant-api03-xxxxx"' >> ~/.zshrc
source ~/.zshrc

# Verifica autenticazione
claude --print-auth-status

# Attivare Plan Mode con Shift+Tab+Tab, poi scrivere il prompt:
> Aggiungi validazione email al form di registrazione

# Claude risponde con un piano:
# Piano di Esecuzione:
# 1. Leggere src/app/auth/register.component.ts
# 2. Leggere src/app/auth/register.component.html
# 3. Aggiungere validatore email al FormGroup
# 4. Aggiungere messaggio di errore nel template
# 5. Aggiungere test per la validazione email
# 6. Aggiornare il service di validazione
#
# File coinvolti: 4
# Operazioni: 6
#
# Procedere? [y/n]

# Pattern 1: Reset del contesto per un nuovo task
/clear
/add-dir ./src/features/new-feature
Implementa il componente UserProfile seguendo i pattern esistenti

# Pattern 2: Verifica stato prima di operazioni critiche
/status
/permissions
Esegui il refactoring del modulo di pagamento

# Pattern 3: Cambio modello per task specifici
/model claude-sonnet-4-20250514    # Per task rapidi e frequenti
Genera i test boilerplate per tutti i service
/model claude-opus-4-20250514      # Per task complessi
Analizza l'architettura e proponi miglioramenti

# Pattern 4: Debug di connessioni MCP
/mcp
# Verifica che i server necessari siano connessi
# prima di eseguire task che li richiedono

# Code Review Completa

Esegui una code review approfondita dei file modificati.

## Checklist
1. Verifica la correttezza logica del codice
2. Controlla naming conventions e coerenza
3. Identifica potenziali bug o edge case
4. Verifica la gestione degli errori
5. Controlla la copertura dei test
6. Valuta la performance e la scalabilità

## Output
Produci un report strutturato con:
- **Severita**: Critical / Major / Minor / Suggestion
- **File e riga**: Riferimento preciso
- **Problema**: Descrizione chiara
- **Soluzione**: Fix proposto con codice

# Verifica Pre-Deploy

Prima di procedere con il deploy, controlla:

1. Esegui `npm run build` e verifica che non ci siano errori
2. Esegui `npm test` e verifica che tutti i test passino
3. Controlla che non ci siano console.log rimasti nel codice
4. Verifica che le variabili d'ambiente siano configurate
5. Controlla che il file .env.production sia aggiornato
6. Verifica la versione nel package.json

Riporta lo stato di ogni punto con un checkmark.

{
  "permissions": {
    "deny": [
      "Bash(rm -rf /*)",
      "Bash(sudo *)",
      "Bash(chmod 777 *)",
      "Write(~/.ssh/*)",
      "Write(~/.aws/*)"
    ]
  },
  "security": {
    "max_file_size_bytes": 10485760,
    "blocked_domains": ["*.internal.company.com"],
    "require_approval_for_network": true
  },
  "model": {
    "default": "claude-sonnet-4-20250514",
    "allowed": ["claude-sonnet-4-20250514", "claude-opus-4-20250514"]
  }
}

{
  "permissions": {
    "allow": [
      "Bash(npm run test:watch)",
      "Bash(npm run dev)",
      "Bash(docker compose up -d)"
    ]
  },
  "preferences": {
    "model": "claude-opus-4-20250514",
    "theme": "dark",
    "auto_approve_reads": true
  }
}

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(mvn *)",
      "Bash(gradle *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Read(*)",
      "Write(src/**/*)"
    ],
    "deny": [
      "Bash(git push --force *)",
      "Bash(git reset --hard *)",
      "Bash(rm -rf *)",
      "Write(.env*)",
      "Write(**/credentials*)",
      "Write(**/secrets*)"
    ]
  },
  "context": {
    "include_patterns": ["src/**/*.ts", "src/**/*.html", "src/**/*.css"],
    "exclude_patterns": ["node_modules/**", "dist/**", ".angular/**"]
  }
}

{
  "permissions": {
    "allow": [
      "Bash(ls *)",
      "Bash(cat *)",
      "Bash(which *)",
      "Bash(node --version)",
      "Read(*)"
    ]
  },
  "preferences": {
    "model": "claude-sonnet-4-20250514",
    "auto_approve_reads": true,
    "verbose_output": false,
    "language": "it"
  }
}

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(npm test *)",
      "Bash(npm install *)",
      "Bash(npx *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Bash(git branch *)",
      "Bash(git checkout *)",
      "Bash(git add *)",
      "Bash(git commit *)",
      "Bash(tsc *)",
      "Bash(ng *)",
      "Bash(mvn *)",
      "Bash(gradle *)",
      "Bash(python -m pytest *)",
      "Bash(docker compose *)",
      "Bash(curl *)",
      "Read(*)",
      "Write(src/**/*)",
      "Write(tests/**/*)",
      "Write(docs/**/*)"
    ],
    "deny": [
      "Write(.env*)",
      "Write(**/*.pem)",
      "Write(**/*.key)",
      "Write(**/credentials*)",
      "Write(**/secrets*)",
      "Write(~/.ssh/*)",
      "Write(~/.aws/*)",
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Bash(chmod 777 *)",
      "Bash(git push --force *)",
      "Bash(git reset --hard *)"
    ]
  }
}

{
  "permissions": {
    "allow": [
      "Read(src/**/*)",
      "Read(tests/**/*)",
      "Read(docs/**/*)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)"
    ],
    "deny": [
      "Write(*)",
      "Bash(npm install *)",
      "Bash(npx *)",
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(ssh *)",
      "Bash(scp *)",
      "Bash(nc *)",
      "Bash(git push *)",
      "Bash(git commit *)",
      "Bash(docker *)",
      "Bash(sudo *)",
      "Bash(rm *)",
      "Bash(mv *)",
      "Bash(cp *)"
    ]
  },
  "security": {
    "require_approval_for_all_writes": true,
    "require_approval_for_network": true,
    "audit_log": true,
    "max_file_modifications_per_session": 10
  }
}

# Sintassi base
claude --print "Analizza il codice in src/ e riporta i problemi" --output-format json

# Con limite di iterazioni
claude --print "Esegui i test e correggi i fallimenti" \
  --output-format json \
  --max-iterations 10

# Con modello specifico
claude --print "Genera la documentazione API" \
  --output-format json \
  --model claude-sonnet-4-20250514

# Con permessi espliciti
claude --print "Formatta tutti i file TypeScript" \
  --output-format json \
  --allowedTools "Bash(npx prettier --write src/**/*.ts)" \
  --allowedTools "Read(*)"

name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          DIFF=$(git diff origin/main...HEAD)
          claude --print "Analizza il seguente diff e fornisci una code review:
          $DIFF

          Formato output:
          - Severity: Critical/Major/Minor
          - File e riga
          - Problema
          - Soluzione proposta" \
            --output-format json \
            --max-iterations 5 > review.json

      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = JSON.parse(fs.readFileSync('review.json', 'utf8'));
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: review.result
            });

#!/bin/bash
# Script per fix automatico di lint errors

echo "=== Claude Code Auto-Fix ==="
echo "Analizzando errori di lint..."

# Esegui lint e cattura errori
LINT_OUTPUT=$(npm run lint 2>&1 || true)

if [ -z "$LINT_OUTPUT" ]; then
  echo "Nessun errore trovato!"
  exit 0
fi

echo "Trovati errori. Avvio Claude Code per la correzione..."

claude --print "Correggi i seguenti errori di lint:
$LINT_OUTPUT

Regole:
- Correggi solo gli errori segnalati
- Non modificare la logica del codice
- Mantieni lo stile esistente" \
  --output-format json \
  --max-iterations 15 \
  --allowedTools "Read(src/**/*)" \
  --allowedTools "Write(src/**/*)" \
  --allowedTools "Bash(npm run lint)"

echo "Fix completato. Verifica finale..."
npm run lint

# Verificare la versione installata
claude --version

# Verificare lo stato dell'autenticazione
claude --print-auth-status

# Avviare in modalità debug verbose
claude --verbose

# Verificare la configurazione attiva
claude --print "Mostra la configurazione attiva" --output-format json

# Reset completo della configurazione
rm -rf ~/.claude/settings.json
claude  # Ricrea la configurazione di default

# Verifica connettivita API
curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2024-01-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-4-20250514","max_tokens":10,"messages":[{"role":"user","content":"test"}]}'

# 1. Entrare nella directory del progetto
cd ~/projects/my-app

# 2. Avviare Claude Code
claude

# 3. Verificare lo stato del repository
> !git status
> !git log --oneline -5

# 4. Caricare il contesto del task corrente
> @src/features/user-profile/
> Sto lavorando sulla feature user-profile.
> Cosa è stato fatto finora e cosa resta da implementare?

# 5. Attivare Plan Mode per il primo task
> [Shift+Tab+Tab] Implementa la validazione del form di profilo

# Implementazione feature
> Implementa il componente EditProfile con form reattivo
> Usa i validatori Angular per email, telefono e nome
> Segui i pattern esistenti in src/features/auth/

# Test
> Genera unit test per EditProfileComponent
> Copri i casi: form valido, email invalida, submit e cancel

# Code review
> /review   # Usa il custom command creato in precedenza

# Commit
> !git add -A
> !git commit -m "feat(user-profile): add edit profile form with validation"

# Passare al task successivo
> /clear
> @src/features/notifications/
> Implementa il sistema di notifiche push

{
  "permissions": {
    "allow": [
      "Read(*)",
      "Write(packages/*/src/**/*)",
      "Write(packages/*/tests/**/*)",
      "Bash(npm run -w packages/* *)",
      "Bash(npx turbo run *)",
      "Bash(git *)"
    ],
    "deny": [
      "Write(packages/*/node_modules/**)",
      "Write(packages/*/.env*)",
      "Bash(rm -rf *)",
      "Bash(sudo *)"
    ]
  },
  "context": {
    "include_patterns": [
      "packages/*/src/**/*.ts",
      "packages/*/package.json",
      "turbo.json",
      "package.json"
    ],
    "exclude_patterns": [
      "**/node_modules/**",
      "**/dist/**",
      "**/.turbo/**"
    ]
  }
}