14 - Copilot Spaces e Memory

Copilot Spaces, Agentic Memory e Repository Indexing

Uno dei fattori più' critici che determina la qualità' delle risposte di un assistente AI e' il contesto. Più' un modello di linguaggio comprende il tuo progetto, le tue convenzioni e i tuoi obiettivi, migliori saranno i suggerimenti che produce. Fino a poco tempo fa, fornire contesto a Copilot richiedeva sforzi manuali: aprire file rilevanti, scrivere prompt dettagliati, ripetere informazioni gia' fornite in sessioni precedenti.

Con l'introduzione di Copilot Spaces, Agentic Memory e i miglioramenti al Repository Indexing, GitHub ha affrontato questo problema in modo strutturale. Questi tre strumenti lavorano in sinergia per garantire che Copilot abbia sempre il contesto giusto al momento giusto, riducendo drasticamente la necessità' di ripetere informazioni e migliorando la coerenza delle risposte nel tempo.

In questo quattordicesimo articolo della serie, esploreremo in dettaglio ciascuno di questi strumenti: come funzionano, come configurarli e come utilizzarli al meglio per massimizzare la produttività' nel lavoro quotidiano.

Copilot Spaces: Organizzare il Contesto per Conversazioni Mirate

Copilot Spaces e' una funzionalità' che permette di creare raccolte organizzate di contesto per conversazioni con Copilot. Uno Space e' essenzialmente un contenitore dove puoi includere diversi tipi di informazioni rilevanti per un determinato task, progetto o area di lavoro. Invece di dover spiegare ogni volta a Copilot su cosa stai lavorando, crei uno Space una volta e lo riutilizzi per tutte le conversazioni relative a quel contesto.

Cosa Puoi Includere in uno Space

La forza di Spaces risiede nella flessibilità' dei tipi di contenuto supportati. Non sei limitato al solo codice: puoi includere qualsiasi informazione utile per dare a Copilot il contesto necessario.

Smart Loading: Contesto Intelligente

Un aspetto fondamentale di Spaces e' il meccanismo di Smart Loading. Quando includi un repository in uno Space, Copilot non carica l'intero contenuto del repository nel contesto della conversazione. Questo sarebbe impossibile per repository di grandi dimensioni e inefficiente anche per quelli piccoli.

Invece, Smart Loading funziona in modo simile a un motore di ricerca semantico: quando fai una domanda, Copilot cerca e recupera dinamicamente solo i file e le sezioni di codice rilevanti per la tua richiesta specifica. Questo approccio offre il meglio di entrambi i mondi: hai accesso all'intero repository come fonte di contesto, ma solo le parti rilevanti occupano la finestra di contesto del modello.

Creare e Gestire Spaces

La creazione di uno Space avviene tramite l'interfaccia web di GitHub o direttamente dall'IDE. Il processo e' semplice e intuitivo.

Creazione di uno Space per un Progetto

SPACE: "E-commerce Backend"

REPOSITORY INCLUSI:
- org/ecommerce-api (repository principale)
- org/shared-libs (librerie condivise)
- org/ecommerce-docs (documentazione)

FILE SPECIFICI:
- ecommerce-api/src/models/*.ts (tutti i modelli dati)
- ecommerce-api/prisma/schema.prisma (schema database)
- ecommerce-api/.copilot-instructions.md (convenzioni del progetto)
- ecommerce-api/docs/architecture.md (decisioni architetturali)

ISSUE INCLUSE:
- #234: "Migrare a Event-Driven Architecture" (in discussione)
- #267: "Performance degradation on product search" (bug critico)

TESTO LIBERO:
"Questo progetto usa NestJS con Prisma ORM. Il database e' PostgreSQL.
L'autenticazione e' basata su JWT con refresh token.
Le API seguono il pattern CQRS con event sourcing per gli ordini.
Usiamo il pattern Repository per l'accesso ai dati.
I test seguono la piramide: 70% unit, 20% integration, 10% E2E.
Il deploy avviene tramite GitHub Actions su AWS ECS."

Casi d'Uso per Spaces

Spaces e' particolarmente utile in scenari dove il contesto e' complesso, distribuito su più' repository o dove diverse persone del team lavorano su aspetti diversi dello stesso progetto.

Best Practice per Spaces

Agentic Memory: Memoria Persistente per Copilot

La Agentic Memory e' una delle funzionalità' più' rivoluzionarie introdotte in Copilot, attualmente disponibile in Early Access per gli utenti dei piani Pro e Pro+. Si tratta di un sistema di memoria persistente che permette a Copilot di ricordare informazioni apprese durante le interazioni precedenti, eliminando la necessità' di ripetere le stesse spiegazioni in ogni nuova sessione di chat.

Come Funziona la Memoria

La Agentic Memory funziona attraverso un processo di deduzione automatica. Durante le conversazioni con Copilot, il sistema identifica informazioni che potrebbero essere utili in futuro e le salva come "memorie". Queste memorie non sono copie esatte delle conversazioni, ma sintesi strutturate delle informazioni chiave dedotte dall'interazione.

Tipi di Memorie

Il sistema non memorizza tutto indiscriminatamente. Le memorie vengono categorizzate e filtrate per rilevanza, focalizzandosi su informazioni che hanno un alto valore di riutilizzo.

Persistenza e Scadenza

Le memorie hanno un ciclo di vita ben definito, progettato per bilanciare utilita' e rilevanza nel tempo.

Scope Repository-Specific

Un aspetto fondamentale della Agentic Memory e' che le memorie sono specifiche per repository. Le informazioni apprese lavorando sul repository A non vengono utilizzate quando lavori sul repository B. Questo design garantisce che il contesto sia sempre pertinente e previene contaminazioni tra progetti diversi.

Questa scelta progettuale ha implicazioni importanti: le convenzioni del progetto A non influenzeranno i suggerimenti per il progetto B, anche se usi lo stesso account Copilot. Ogni repository ha il suo "cervello" indipendente, che cresce e si arricchisce solo con le interazioni specifiche per quel repository.

Auto-Compattazione

Quando il volume delle memorie raggiunge il 95% del limite massimo di token allocato, il sistema attiva un processo di auto-compattazione. Le memorie vengono valutate in base a frequenza di utilizzo, recenza e rilevanza. Le memorie meno utilizzate vengono condensate o rimosse per fare spazio a nuove informazioni.

Questo meccanismo garantisce che il "cervello" di Copilot per ogni repository rimanga focalizzato sulle informazioni più' utili, senza accumulare detriti informativi che potrebbero degradare la qualità' delle risposte. E' un processo automatico che non richiede intervento dell'utente, anche se e' possibile gestire manualmente le memorie se necessario.

Vantaggi Pratici della Agentic Memory

Gestione Manuale delle Memorie

Nonostante il sistema sia progettato per essere automatico, gli utenti hanno pieno controllo sulle memorie memorizzate. Puoi:

• Visualizzare: Accedere alla lista completa delle memorie per ogni repository
• Modificare: Correggere memorie imprecise o aggiungere dettagli
• Eliminare: Rimuovere memorie obsolete o errate
• Forzare la creazione: Puoi esplicitamente chiedere a Copilot di ricordare qualcosa

// Nella chat di Copilot, puoi dire:

"Ricorda che in questo progetto usiamo sempre
il pattern Result<T, E> per la gestione degli errori
invece di lanciare eccezioni. Ogni servizio deve
restituire Result<SuccessType, ErrorType>."

"Ricorda che le migrazioni del database vanno sempre
create con il comando: npx prisma migrate dev --name <nome-descrittivo>"

"Ricorda che il nostro naming convention per i branch e':
feature/JIRA-XXX-breve-descrizione
fix/JIRA-XXX-breve-descrizione
chore/JIRA-XXX-breve-descrizione"

"Ricorda che i test di integrazione devono usare
il database di test (TEST_DATABASE_URL) e non il
database di sviluppo."

Repository Indexing: Ricerca Semantica Istantanea

Il Repository Indexing e' il motore che alimenta la comprensione profonda del codice da parte di Copilot. Quando un repository viene indicizzato, Copilot crea una rappresentazione semantica del codice che gli permette di comprendere non solo la struttura dei file, ma anche le relazioni logiche tra componenti, le dipendenze tra moduli e il flusso dei dati attraverso il sistema.

Indicizzazione Automatica

L'indicizzazione avviene automaticamente la prima volta che un utente avvia una conversazione Copilot Chat in un repository. Non e' necessaria alcuna configurazione o azione manuale. Una volta completata l'indicizzazione, tutti gli utenti Copilot che accedono a quel repository beneficiano dell'indice condiviso.

Cosa Viene Indicizzato

L'indicizzazione va ben oltre un semplice indice di ricerca testuale. Il sistema crea una comprensione semantica del codice che include:

Velocita' di Indicizzazione

Una delle innovazioni più' significative e' la riduzione del tempo di indicizzazione a meno di 60 secondi. Nelle versioni precedenti, l'indicizzazione poteva richiedere minuti o anche ore per repository di grandi dimensioni. Oggi, grazie a ottimizzazioni nell'algoritmo di embedding e nell'infrastruttura di indicizzazione, la ricerca semantica e' disponibile quasi istantaneamente.

Dopo l'indicizzazione iniziale, gli aggiornamenti sono incrementali: quando fai push di nuovi commit, solo i file modificati vengono re-indicizzati, mantenendo l'indice sempre aggiornato senza richiedere una re-indicizzazione completa.

Impatto sulla qualità' delle Risposte

Il Repository Indexing ha un impatto diretto e misurabile sulla qualità' delle risposte di Copilot. Senza indicizzazione, Copilot può' vedere solo i file attualmente aperti nell'editor. Con l'indicizzazione, ha accesso all'intera base di codice.

Enterprise Controls

Per le organizzazioni, il Repository Indexing offre controlli granulari per gestire quali contenuti vengono indicizzati e quali esclusi. Questo e' particolarmente importante per repository che contengono codice sensibile o informazioni proprietarie.

# File e cartelle da escludere dall'indicizzazione Copilot
# Simile a .gitignore ma specifico per Copilot

# Secrets e credenziali
.env
.env.*
**/secrets/
**/credentials/
**/*.pem
**/*.key

# Dati sensibili
**/fixtures/customers.json
**/seed/production-data.sql

# Codice proprietario
src/core/proprietary-algorithm/
src/core/patent-pending/

# File generati (rumore nell'indicizzazione)
dist/
build/
node_modules/
coverage/
*.min.js
*.bundle.js

# Vendor code
vendor/
third-party/

# File di grandi dimensioni (non utili per il contesto)
**/*.csv
**/*.sql.gz
**/*.dump

Sinergia tra Spaces, Memory e Indexing

La vera potenza di questi tre strumenti emerge quando lavorano insieme. Ciascuno copre un aspetto diverso del problema del contesto, e insieme forniscono a Copilot una comprensione completa e persistente del progetto.

In pratica, quando fai una domanda a Copilot:

1. Repository Indexing recupera i file e le strutture di codice rilevanti
2. Spaces aggiunge il contesto aggiuntivo (issue, PR, documentazione, note)
3. Agentic Memory applica le convenzioni e le preferenze apprese nelle sessioni precedenti
4. Tutti questi contesti vengono combinati e inviati al modello per generare la risposta

Esempi Pratici

Vediamo come questi strumenti si applicano in scenari di lavoro quotidiano.

Esempio 1: Setup Space per Progetto Multi-Repo

PROGETTO: E-commerce platform con 5 microservizi

REPOSITORY:
1. ecommerce-gateway (API Gateway - Node.js)
2. ecommerce-products (Catalogo prodotti - Python/FastAPI)
3. ecommerce-orders (Gestione ordini - Java/Spring Boot)
4. ecommerce-payments (Pagamenti - Go)
5. ecommerce-notifications (Notifiche - Node.js)

SPACE CONSIGLIATO: "E-commerce Platform"

CONTENUTI:
- Tutti i 5 repository
- File proto/ con le definizioni gRPC condivise
- File di OpenAPI di ogni servizio
- Documento di architettura (C4 model)
- ADR (Architecture Decision Records)
- Note sul team: "Il team payments e' esterno,
  comunicazione via Slack #payments-integration"

RISULTATO:
Quando chiedi "Come funziona il flusso di checkout?",
Copilot può' tracciare il flusso attraverso tutti i servizi:
Gateway -> Products (verifica disponibilità')
        -> Orders (crea ordine)
        -> Payments (processa pagamento)
        -> Notifications (invia conferma)

Esempio 2: Utilizzo della Memory per Convenzioni

SESSIONE 1 (Giorno 1):
Developer: "Crea un nuovo servizio per la gestione delle fatture"
Copilot genera il servizio seguendo pattern generici.
Developer: "No, nel nostro progetto i servizi seguono sempre
questo pattern: InvoiceService extends BaseService<Invoice>
con i metodi findById, findAll, create, update, delete.
Usiamo anche il decorator @Injectable() e il pattern
Result<T, E> per gli errori."
Copilot genera la versione corretta.
>> MEMORIA CREATA: "I servizi seguono il pattern
BaseService<T> con decorator @Injectable() e Result<T,E>"

SESSIONE 2 (Giorno 5):
Developer: "Crea un servizio per gestire i clienti"
Copilot genera automaticamente:
- CustomerService extends BaseService<Customer>
- @Injectable() decorator
- Tutti i metodi CRUD con Result<T, E>
- Error handling coerente con InvoiceService
>> NESSUNA ISTRUZIONE AGGIUNTIVA NECESSARIA

Esempio 3: Repository Indexing per Code Exploration

CONTESTO: Nuovo sviluppatore sul progetto (50K righe di codice)

DOMANDE E RISPOSTE (con Repository Indexing):

D: "Come e' strutturato il progetto?"
R: Il progetto segue una Clean Architecture con 4 layer:
   - src/domain/ (entità' e business rules)
   - src/application/ (use cases)
   - src/infrastructure/ (database, API esterne)
   - src/presentation/ (controller, DTO, middleware)
   [cita file e cartelle specifiche]

D: "Come funziona l'autenticazione?"
R: L'autenticazione usa JWT con refresh token:
   - src/infrastructure/auth/jwt.strategy.ts (validazione)
   - src/infrastructure/auth/auth.guard.ts (protezione route)
   - src/application/auth/auth.service.ts (logica di login)
   [mostra il flusso con riferimenti al codice reale]

D: "Dove devo mettere un nuovo endpoint per i report?"
R: Basandomi sulla struttura del progetto:
   - Controller: src/presentation/controllers/report.controller.ts
   - Service: src/application/services/report.service.ts
   - Repository: src/infrastructure/repositories/report.repository.ts
   - DTO: src/presentation/dto/report.dto.ts
   - Test: test/unit/report.service.spec.ts
   [segue esattamente il pattern degli altri endpoint]

Configurazione Avanzata

Per sfruttare al massimo questi strumenti, e' importante configurarli correttamente in base alle esigenze del progetto e del team.

File .copilot-instructions.md

Il file .copilot-instructions.md nella root del repository viene automaticamente incluso nel contesto di ogni conversazione Copilot. E' il modo più' diretto per fornire istruzioni persistenti a Copilot per un repository specifico.

# Istruzioni per Copilot

## Stack Tecnologico
- Backend: NestJS 10 con TypeScript 5.3
- Database: PostgreSQL 16 con Prisma 5
- Cache: Redis 7
- Queue: BullMQ
- Testing: Jest + Supertest
- Linting: ESLint + Prettier

## Convenzioni di Coding

### Naming
- File: kebab-case (user.service.ts)
- Classi: PascalCase (UserService)
- Metodi: camelCase (findById)
- Costanti: UPPER_SNAKE_CASE (MAX_RETRY_COUNT)
- Interfacce: PascalCase con prefisso I (IUserRepository) -- NO, senza prefisso

### Pattern
- Servizi: estendono BaseService<T>
- Repository: implementano IRepository<T>
- Controller: usano @Controller() decorator con path plurale (/users, /orders)
- DTO: usano class-validator per validazione
- Errori: Result<T, AppError> pattern (mai throw eccezioni)

### Testing
- Unit test: file.spec.ts nella stessa cartella del sorgente
- Integration test: test/integration/ con database di test
- E2E test: test/e2e/ con supertest
- Coverage target: 80% per servizi, 60% per controller

### Git
- Branch: feature/PROJ-XXX-descrizione, fix/PROJ-XXX-descrizione
- Commit: conventional commits (feat:, fix:, chore:, docs:)
- PR: template in .github/PULL_REQUEST_TEMPLATE.md

## Regole di Business
- I prezzi sono sempre in centesimi (integer, mai float)
- Le date sono sempre in UTC
- Gli ID sono UUID v4
- Soft delete per tutte le entità' (campo deletedAt)
- Audit trail per ogni operazione CRUD (campo createdBy, updatedBy)

Ottimizzare l'Indicizzazione

Per migliorare la qualità' dell'indicizzazione e le performance della ricerca semantica, segui queste linee guida:

Confronto con Approcci Alternativi

Per contestualizzare Spaces, Memory e Indexing, e' utile confrontarli con approcci alternativi per fornire contesto all'AI.

Limitazioni e Considerazioni

Nonostante i vantaggi evidenti, e' importante conoscere le limitazioni attuali di questi strumenti per utilizzarli con aspettative realistiche.

Privacy e Sicurezza dei Dati

Un aspetto importante da considerare, specialmente per team enterprise, riguarda la privacy e la sicurezza dei dati utilizzati da questi strumenti.

Conclusione

Copilot Spaces, Agentic Memory e Repository Indexing rappresentano un salto qualitativo nel modo in cui forniamo contesto agli strumenti AI di sviluppo. Invece di ripetere le stesse informazioni ad ogni sessione, possiamo costruire un ecosistema di contesto persistente che cresce e si arricchisce nel tempo.

La combinazione di questi tre strumenti copre tutti gli aspetti del contesto: il codice (Repository Indexing), le informazioni esterne (Spaces) e la conoscenza implicita (Memory). Insieme, trasformano Copilot da un assistente generico a un partner che conosce il tuo progetto, le tue convenzioni e le tue preferenze.

Il consiglio pratico e': inizia con il Repository Indexing (automatico), aggiungi un file .copilot-instructions.md con le convenzioni del progetto, e poi crea Spaces per i contesti più' complessi. La Memory si costruira' naturalmente nel tempo attraverso le tue interazioni quotidiane.