16 - Personalizzazione Avanzata di Copilot

# Profilo Sviluppatore
Sono un senior full-stack developer con 8 anni di esperienza.
Stack principale: Java (Spring Boot), TypeScript (Angular), PostgreSQL.
Lavoro su architetture a microservizi in ambiente cloud (AWS).

# Preferenze Lingua
Rispondi sempre in italiano.
Usa terminologia tecnica in inglese quando appropriato
(es. "dependency injection", "middleware", "endpoint").

# Stile di Risposta
- Sii conciso e vai dritto al punto
- Fornisci sempre esempi di codice quando possibile
- Includi commenti nel codice solo per logica complessa
- Specifica le versioni quando suggerisci dipendenze
- Segnala potenziali problemi di performance o sicurezza

# Convenzioni di Codice
- Java: Google Java Style Guide
- TypeScript: ESLint con configurazione strict
- SQL: uppercase per keywords, lowercase per nomi tabelle
- Naming: camelCase per variabili, PascalCase per classi
- Test: pattern Given-When-Then per test names

# Anti-Pattern da Evitare
- Non suggerire mai codice senza gestione errori
- Non usare "any" in TypeScript
- Non suggerire query SQL con SELECT *
- Non ignorare la validazione degli input

# Copilot Instructions per TaskFlow Frontend

## Stack Tecnologico
- Framework: Angular 21 con standalone components
- Linguaggio: TypeScript 5.9 strict mode
- Styling: SCSS con BEM methodology
- State Management: Angular Signals
- HTTP: Angular HttpClient con interceptors
- Routing: Angular Router con lazy loading
- Testing: Jasmine + Karma per unit, Cypress per E2E

## Convenzioni di Codice

### Componenti
- Usa SEMPRE standalone components (no NgModules)
- Change detection: OnPush per tutti i componenti
- Usa signals() per stato reattivo, non BehaviorSubject
- Template: file separato (.html) per componenti > 20 righe
- Stili: file separato (.scss) sempre

### Naming Conventions
- Componenti: PascalCase con suffisso Component (es. UserProfileComponent)
- Servizi: PascalCase con suffisso Service (es. AuthService)
- Interfacce: PascalCase con prefisso I (es. IUserProfile)
- File: kebab-case (es. user-profile.component.ts)
- Costanti: UPPER_SNAKE_CASE (es. MAX_RETRY_COUNT)

### Pattern Obbligatori
- Ogni servizio HTTP deve avere error handling centralizzato
- Usare pipe async o toSignal() nel template, mai subscribe manuale
- Route guards come functional guards (non class-based)
- Form: reactive forms con FormBuilder, mai template-driven
- Validazione: custom validators in file separato

### Struttura Directory
```
src/app/
  features/       # Feature modules (lazy loaded)
  shared/         # Componenti, pipe, direttive condivise
  core/           # Servizi singleton, interceptors, guards
  models/         # Interfacce e tipi
  environments/   # Configurazioni ambiente
```

### Testing
- Ogni componente DEVE avere unit test
- Coverage minima: 80% per servizi, 70% per componenti
- Mock pattern: usa jasmine.createSpyObj per dipendenze
- Naming test: "should [expected behavior] when [condition]"

### Performance
- Lazy load tutte le feature routes
- Usa trackBy per *ngFor (o @for con track)
- Immagini: usa NgOptimizedImage
- Bundle size alert: > 500KB per chunk e' un warning

### Accessibilita'
- Ogni elemento interattivo deve avere aria-label
- Contrasto colori: WCAG AA (4.5:1 minimo)
- Tab navigation deve funzionare per tutti i form
- Screen reader: testare con NVDA o VoiceOver

---
applyTo: "**/*.spec.ts"
---

# Istruzioni per File di Test

## Struttura Test
- Usa describe() per raggruppare test per metodo/funzionalità'
- Usa beforeEach() per setup comune
- Pattern AAA: Arrange, Act, Assert in ogni test

## Naming Convention
- describe: nome della classe/funzione sotto test
- it/test: "should [cosa fa] when [condizione]"

## Mock Pattern
```typescript
const mockService = jasmine.createSpyObj('ServiceName', ['method1', 'method2']);
mockService.method1.and.returnValue(of(expectedResult));
```

## Coverage Requirements
- Branch coverage: >= 80%
- Line coverage: >= 85%
- Ogni path condizionale deve avere almeno un test

## Anti-Pattern da Evitare
- Non testare dettagli implementativi
- Non fare mock di tutto (testa integrazione dove possibile)
- Non usare setTimeout() nei test (usa fakeAsync/tick)
- Non ignorare test flaky: fixali o rimuovili

---
applyTo: "src/app/core/services/**/*.ts"
---

# Istruzioni per Servizi API

## Pattern Obbligatorio
Ogni servizio API deve seguire questo pattern:

```typescript
@Injectable({ providedIn: 'root' })
export class EntityService {
  private readonly apiUrl = `${environment.apiUrl}/entities`;

  constructor(private http: HttpClient) {}

  getAll(): Observable<Entity[]> {
    return this.http.get<Entity[]>(this.apiUrl).pipe(
      catchError(this.handleError)
    );
  }

  private handleError(error: HttpErrorResponse): Observable<never> {
    // Centralizzato nell'interceptor, qui solo log specifico
    console.error(`EntityService error: ${error.message}`);
    return throwError(() => error);
  }
}
```

## Regole
- Tutti i metodi HTTP devono restituire Observable<T>
- Error handling tramite interceptor globale + log locale
- URL base da environment, mai hardcoded
- Metodi CRUD standard: getAll, getById, create, update, delete
- Usare HttpParams per query parameters
- Cache con shareReplay(1) dove appropriato

---
applyTo: "src/app/features/**/*.component.ts"
---

# Istruzioni per Componenti Feature

## Template Componente Standard
```typescript
@Component({
  standalone: true,
  selector: 'app-feature-name',
  templateUrl: './feature-name.component.html',
  styleUrls: ['./feature-name.component.scss'],
  changeDetection: ChangeDetectionStrategy.OnPush,
  imports: [CommonModule, ReactiveFormsModule]
})
export class FeatureNameComponent {
  // Signals per stato locale
  readonly items = signal<Item[]>([]);
  readonly loading = signal(false);
  readonly error = signal<string | null>(null);

  // Computed per derivazioni
  readonly itemCount = computed(() => this.items().length);

  // Inject dependencies
  private readonly service = inject(FeatureService);
  private readonly destroyRef = inject(DestroyRef);
}
```

## Regole
- OnPush change detection OBBLIGATORIO
- Signals per tutto lo stato locale
- inject() function, non constructor injection
- DestroyRef per cleanup sottoscrizioni
- Template max 50 righe, altrimenti splitta in sub-componenti

# Copilot Instructions per TaskFlow Backend

## Stack
- Java 21 con Spring Boot 3.3
- Build: Gradle Kotlin DSL
- Database: PostgreSQL 16 con Flyway migrations
- Cache: Redis 7
- Auth: Spring Security + JWT
- API: REST con OpenAPI 3.1 documentation
- Testing: JUnit 5 + Mockito + Testcontainers

## Architettura
Hexagonal Architecture (Ports and Adapters):
```
src/main/java/com/taskflow/
  domain/          # Entità', value objects, eccezioni di dominio
  application/     # Use cases, DTO, port interfaces
  infrastructure/  # Adapter: DB, HTTP, messaging
  config/          # Spring configuration
```

## Convenzioni Java
- Record per DTO immutabili
- Sealed interface per gerarchia tipi controllata
- Optional solo come return type, mai come parametro
- Stream API per operazioni su collection
- Naming: verbo + sostantivo per metodi (es. createOrder, findUserById)

## API Design
- Endpoint: /api/v1/{resource} (plurale)
- Response: wrapper con data, metadata, errors
- Pagination: page, size, sort query params
- Error format: RFC 7807 Problem Details
- Versioning: URL-based (/api/v1/, /api/v2/)

## Database
- Migrations: Flyway con naming V{version}__{description}.sql
- Naming tabelle: snake_case, plurale (es. user_profiles)
- Ogni tabella: id (UUID), created_at, updated_at
- Indici: su tutte le foreign key e campi di ricerca frequente
- NO cascade delete: gestire esplicitamente

## Security
- Input validation su TUTTI gli endpoint
- SQL injection: solo PreparedStatement/JPA
- Rate limiting: 100 req/min per user
- CORS: whitelist esplicita
- Secrets: mai in codice, sempre da environment

# Acme Corp - GitHub Copilot Instructions

## Lingua
Rispondi sempre in italiano per il team italiano,
in inglese per tutti gli altri.

## Standard di Sicurezza
- Non suggerire mai codice che espone secrets o credenziali
- Includi sempre input validation negli endpoint
- Usa prepared statements per tutte le query database
- Implementa rate limiting su ogni API pubblica
- Log sensibili: mai loggare PII, token o password

## Convenzioni Codice Aziendali
- Tutti i servizi devono avere interfaccia + implementazione
- Naming: prefisso "Acme" per package base (com.acme.*)
- Documentazione JavaDoc obbligatoria per metodi pubblici
- Commit message: Conventional Commits format
- Branch naming: feature/, bugfix/, hotfix/ + JIRA ticket

## Compliance
- Codice deve essere compatibile GDPR
- Dati utente: sempre criptati a riposo
- Log retention: max 90 giorni
- Audit trail obbligatorio per operazioni CRUD su dati sensibili

## Librerie Approvate
- HTTP Client: OkHttp o Spring WebClient (no Apache HC legacy)
- JSON: Jackson (no Gson)
- Logging: SLF4J + Logback
- Testing: JUnit 5 + AssertJ + Mockito

{
  "servers": {
    "github": {
      "type": "remote",
      "url": "https://api.githubcopilot.com/mcp/github",
      "description": "GitHub API access for issues, PRs, repos"
    },
    "postgres-local": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/taskflow"
      ],
      "description": "Local PostgreSQL database access"
    },
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "--root",
        "${workspaceFolder}"
      ],
      "description": "File system access for project files"
    },
    "documentation": {
      "type": "remote",
      "url": "https://docs-mcp.example.com/v1",
      "headers": {
        "Authorization": "Bearer ${env:DOCS_API_KEY}"
      },
      "description": "Internal documentation search"
    },
    "sentry": {
      "type": "remote",
      "url": "https://mcp.sentry.io/sse",
      "headers": {
        "Authorization": "Bearer ${env:SENTRY_AUTH_TOKEN}"
      },
      "description": "Sentry error tracking integration"
    }
  }
}

# Formato: un pattern per riga
# Supporta glob patterns

# Escludere file di configurazione sensibili
*.env
*.env.*
config/secrets/**

# Escludere codice legacy non modificabile
legacy/**
vendor/**

# Escludere file generati automaticamente
generated/**
dist/**
node_modules/**

# Escludere file con dati sensibili
**/credentials*
**/private-keys/**
**/*.pem
**/*.key

# Escludere directory specifiche
src/app/proprietary/**
src/internal/billing/**

# Escludere file di test con dati sensibili
test/fixtures/sensitive-data/**

my-project/
  .github/
    copilot-instructions.md            # Istruzioni generali del progetto
    instructions/
      testing.instructions.md          # Regole per file di test
      api-controllers.instructions.md  # Regole per controller API
      database.instructions.md         # Regole per query e migrations
      components.instructions.md       # Regole per componenti UI
  .vscode/
    mcp.json                           # Server MCP del progetto
    settings.json                      # Impostazioni VS Code

# A livello organizzazione (UI GitHub):
# - Organization Instructions (4000 char max)
# - Content Exclusion patterns
# - MCP server policy

# A livello personale (Settings GitHub):
# - Personal Instructions
# - Preferenze lingua e stile