Copilot Spaces, Agentic Memory e Indexação de Repositório
Um dos fatores mais críticos que determina a qualidade das respostas de um assistente de IA é o contexto. Quanto mais um modelo de linguagem entende seu projeto, suas convenções e objetivos, melhores serão as sugestões que ele produz. Até recentemente, fornecer contexto ao Copilot exigia esforços manuais: abrir arquivos relevante, escreva instruções detalhadas, repita as informações já fornecidas nas sessões precedentes.
Com a introdução de Espaços Copiloto, Memória Agente e as melhorias Indexação de repositório, o GitHub abordou isso problema de forma estrutural. Estas três ferramentas funcionam em sinergia para garantir que o Copilot sempre tenha o contexto certo na hora certa, reduzindo drasticamente a necessidade de repetir informações e melhorar a consistência das respostas ao longo do tempo.
Neste décimo quarto artigo da série, exploraremos cada um deles detalhadamente essas ferramentas: como funcionam, como configurá-las e como utilizá-las da melhor forma para maximizar a produtividade no trabalho diário.
Visão geral da Série Completa
| # | Artigo | Foco |
|---|---|---|
| 1 | Fundamentos e Mindset | Setup e mentalidade |
| 2 | Ideação e Requisitos | Da ideia ao MVP |
| 3 | Arquitetura Backend | API e banco de dados |
| 4 | Estrutura Frontend | UI e componentes |
| 5 | Prompt Engineering | Prompts e Agentes MCP |
| 6 | Testes e Qualidade | Unitários, Integração, E2E |
| 7 | Documentação | README, API Docs, ADR |
| 8 | Deploy e DevOps | Docker, CI/CD |
| 9 | Evolução | Escalabilidade e manutenção |
| 10 | Coding Agent | Agente autônomo de desenvolvimento |
| 11 | Code Review | Review automática com IA |
| 12 | Copilot Edits | Edição multi-arquivo |
| 13 | GitHub Spark | Apps a partir de linguagem natural |
| 14 | Você está aqui → Spaces e Memory | Contexto organizado e memória |
| 15 | Modelos de IA | Guia de escolha de modelo |
| 16 | Personalização | Instruções personalizadas e knowledge |
| 17 | Enterprise | Copilot para organizações |
| 18 | Extensions | Estender o Copilot com ferramentas |
| 19 | Segurança | Segurança e compliance AI |
Espaços Copiloto: Organizando o Contexto para Conversas Intencionais
Espaços Copiloto É um recurso que permite criar coleções organizadas de contexto para conversas com o Copilot. Um espaço é essencialmente um contêiner onde você pode incluir diferentes tipos de informações relevantes para uma determinada tarefa, projeto ou área de trabalho. Em vez disso de ter que explicar ao Copilot toda vez que você está trabalhando, você cria um Espaço uma vez e reutilizá-lo para todas as conversas relacionadas a esse contexto.
O que você pode incluir em um espaço
A força do Spaces reside na flexibilidade dos tipos de conteúdo suportados. Você não está limitado apenas ao código - você pode incluir qualquer informação que seja útil para dê ao Copilot o contexto necessário.
Tipos de conteúdo suportados
| Tipo | Descrição | Exemplo de uso |
|---|---|---|
| Repository | Interi repository GitHub o cartelle specifiche | Incluir o repositório principal do projeto |
| Arquivo de código | Arquivos únicos ou seleções de código | O modelo de dados, as principais APIs, os arquivos de configuração |
| Pull Request | PRs abertos ou fechados com diferenças e comentários | Relações públicas recentes para entender as últimas mudanças |
| Issue | Problema do GitHub com discussões | Bug aperti, feature request, decisioni architetturali |
| Testo libero | Note, istruzioni, context in formato testo | Convenções de equipe, regras de negócios, requisitos |
| Immagini | Screenshot, diagrammi, wireframe | Projetos de referência, diagramas arquitetônicos |
| File caricati | Documentos, PDFs, arquivos de configuração | Especificações técnicas, documentos de requisitos |
Smart Loading: Contesto Intelligente
Um aspecto fundamental do Spaces é o mecanismo Carregamento inteligente. Ao incluir um repositório em um espaço, o Copilot não carrega todo o conteúdo do repositório no contexto da conversa. Isto seria impossível para repositório grande e ineficiente mesmo para os pequenos.
Em vez disso, o Smart Load funciona de forma semelhante a um mecanismo de pesquisa semântica: quando você faz uma pergunta, Copilot pesquisar e recuperar dinamicamente sozinho os arquivos e seções de código relevantes para sua solicitação específica. Esta abordagem oferece o melhor dos dois mundos: você tem acesso a todo o repositório como fonte de contexto, mas apenas as partes relevantes ocupam a janela de contexto do modelo.
Como funciona o carregamento inteligente
- Indexação: Quando você adiciona um repositório ao Space, ele é indexado para pesquisa semântica
- Consultas: Quando você faz uma pergunta, o Copilot analisa a intenção e identifica tópicos relevantes
- Recuperação: Os arquivos e seções relevantes são recuperados do índice
- Classificação: Os resultados são classificados por relevância
- Montagem de Contexto: Apenas os fragmentos mais relevantes são incluídos no prompt do modelo
- Responder: O modelo gera a resposta com contexto preciso e relevante
Criar e gerenciar espaços
A criação de um espaço ocorre por meio da interface web do GitHub ou diretamente do IDE. O processo é simples e intuitivo.
Criando um espaço para um projeto
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."Casos de uso para espaços
Spaces é particularmente útil em cenários onde o contexto é complexo, distribuído em vários repositórios ou onde diferentes pessoas da equipe trabalham em diferentes aspectos do mesmo projeto.
Scenari d'Uso Comuni
| Scenario | Space Consigliato | Conteúdo a incluir |
|---|---|---|
| Projeto multi-repo | Um espaço por projeto | Tutti i repo, schema condiviso, docs architetturali |
| Onboarding nuovo membro | "Integração [Projeto]" | README, guide setup, ADR, convenzioni, FAQ |
| Bug investigation | "Debug [Feature]" | File coinvolti, issue, log, stack trace |
| Feature development | "Feature [Nome]" | Especificações, wireframes, arquivos para editar, testes existentes |
| Cross-team collaboration | "Integration [Team A + B]" | Contratos de API, esquema compartilhado, documentos de contrato |
| Migration project | "Migration [Legacy → New]" | Código legado, novo destino, mapeamento, plano de migração |
| Code review preparation | "Review [PR #xxx]" | PR, test, documentazione correlata, standard del team |
Melhores práticas para espaços
Pendência
- Crie espaços específicos do contexto (não um espaço genérico para tudo)
- Sempre inclua convenções do projeto (arquivo .copilot-instructions.md)
- Atualize o Espaço conforme o projeto evolui
- Adicione texto livre para informações não presentes no código
- Compartilhe Spaces com membros da equipe
- Incluir código e documentação relacionada
- Use diferentes espaços para diferentes fases (desenvolvimento, depuração, revisão)
Para ser evitado
- Não inclua muitos repositórios irrelevantes (ruído no contexto)
- Não crie um único espaço para todo o trabalho
- Não se esqueça de atualizar o Espaço após mudanças significativas
- Não inclua grandes binários ou ativos
- Não negligencie o texto livre: muitas vezes é o contexto mais valioso
- Não compartilhe Spaces com conteúdo confidencial sem verificar as permissões
- Não sobrecarregue um espaço com dezenas de questões irrelevantes
Memória Agente: Memória Persistente para Copiloto
La Memória Agente É um dos recursos mais revolucionários introduzido no Copilot, atualmente disponível em Acesso antecipado para usuários dos planos Pró e Pró+. Este é um sistema de memória persistente que permite ao Copilot lembre-se de informações aprendido durante interações anteriores, eliminando a necessidade de repita as mesmas explicações em cada nova sessão de chat.
Como funciona a memória
A Memória Agente funciona através de um processo de dedução automática. Durante as conversas com o Copilot, o sistema identifica informações que podem serão úteis no futuro e os salva como "memórias". Essas memórias não são cópias exatas de conversas, mas resumos estruturados de informações importantes deduzido da interação.
Ciclo de vida de uma memória
- Dedução: Durante uma conversa, o Copilot identifica informações potencialmente úteis
- Criação: A informação é sintetizada e salva como uma memória estruturada
- Associação: A memória está associada ao repositório específico no qual foi criada
- Uso: Nas conversas subsequentes no mesmo repositório, a memória é usada como contexto
- Validação: Cada vez que a memória é usada com sucesso, sua vida útil é estendida
- Expiração: As memórias não utilizadas expiram automaticamente após 28 dias
Tipos de memórias
O sistema não armazena tudo indiscriminadamente. Memórias são categorizadas e filtrados por relevância, com foco em informações de alto valor de reutilização.
Categorias de memórias
| Categoria | Esempi | Valore |
|---|---|---|
| Estrutura do projeto | Organização de pastas, arquitetura, módulos principais | Evite ter que reexplicar como o código está organizado |
| Convenções de codificação | Estilo de nomenclatura, padrões usados, regras de linting | Gere código consistente com os padrões da equipe |
| Pattern ricorrenti | Como você cria novos endpoints, como escreve testes, como lida com erros | Reproduz padrões aprovados sem exigir instruções |
| Decisioni tecniche | porque uma biblioteca específica é usada, compensações arquitetônicas | Sugere soluções alinhadas às escolhas da equipe |
| Informações de domínio | Regras de negócios, terminologia específica, restrições regulatórias | Compreende o domínio sem explicações repetidas |
| Preferenze personali | Estilo de comentário, nível de detalhe, formato de resposta | Personalize suas respostas com base em suas preferências |
Persistenza e Scadenza
As memórias têm um ciclo de vida bem definido, projetado para equilibrar a utilidade e relevância ao longo do tempo.
Regras de Persistência
| Regola | Detalhe |
|---|---|
| Durata iniziale | 28 dias a partir da criação |
| Rinnovo | Cada uso redefine o cronômetro de 28 dias |
| Scadenza | Excluir automaticamente após 28 dias de inatividade |
| Scope | Memórias específicas do repositório (não globais) |
| Compattazione | A 95% do limite de tokens, as memórias menos relevantes são compactadas |
| Privacy | As memórias não são compartilhadas entre usuários ou repositórios |
| Cancellazione | O usuário pode excluir manualmente qualquer memória |
| Visibilità' | O usuário pode visualizar todas as memórias ativas |
Scope Repository-Specific
Um aspecto fundamental da Memória Agêntica é que as memórias são específico do repositório. As informações aprendidas durante o trabalho no repositório A não são usados quando você trabalha no repositório B. Este design garante que o contexto seja sempre relevante e evita a contaminação entre projetos diferentes.
Esta escolha de design tem implicações importantes: Convenções do Projeto A eles não afetarão as sugestões para o projeto B, mesmo se você usar a mesma conta Copiloto. Cada repositório tem seu “cérebro” independente, que cresce e se enriquece apenas com interações específicas desse repositório.
Implicações do escopo para repositórios
- Monorepo: Em um monorepo, todas as memórias são compartilhadas entre módulos (preste atenção às diferentes convenções entre módulos)
- Garfo: Os garfos são repositórios separados, portanto as memórias não são transferidas
- Renomear: Renomear repositório preserva memórias (ID interno permanece o mesmo)
- Multi-repositório: Você tem que construir memórias separadas para cada repositório, mesmo que façam parte do mesmo projeto
- Transferências: Transferir um repositório para outra organização preserva memórias
Auto-Compattazione
Quando o volume da memória atingir 95% do limite máximo de token alocado, o sistema ativa um processo autocompactação. As memórias eles são avaliados com base na frequência de uso, atualidade e relevância. Memórias menos utilizados são condensados ou removidos para dar espaço a novas informações.
Este mecanismo garante que o “cérebro” do Copilot para cada repositório permaneça focado nas informações mais úteis, sem acumular detritos de informação que poderia degradar a qualidade das respostas. É um processo automático que não requer intervenção do usuário, embora seja possível gerenciar as memórias manualmente se necessário.
Vantagens Práticas da Memória Agente
Antes e Depois da Memória Agente
| Scenario | Sem memória | Com memória |
|---|---|---|
| Nova sessão de bate-papo | Você precisa reexplicar a estrutura e as convenções do projeto | Copilot já sabe como o projeto está organizado |
| Creazione nuovo endpoint | Você tem que especificar padrão, middleware, validação | Copilot reproduz o padrão de endpoints existentes |
| Risoluzione bug | Você deve descrever como funciona o sistema envolvido | O Copilot conhece a arquitetura e sugere onde procurar |
| Code review | Você tem que explicar as regras da equipe | O Copilot aplica automaticamente as convenções da equipe |
| Refactoring | Você precisa definir a arquitetura alvo | O Copilot conhece suas preferências arquitetônicas |
| Testing | Devi specificare framework, stile, coverage target | Copilot gera testes consistentes com os existentes |
| Documentação | Devi indicare formato, stile, convenzioni | Copilot produz documentos alinhados com o restante do projeto |
Gerenciamento manual de memória
Embora o sistema seja projetado para ser automático, os usuários têm plena controle sobre as memórias armazenadas. Você pode:
- Visualizar: Acesse a lista completa de memórias de cada repositório
- Modificare: Correggere memorie imprecise o aggiungere dettagli
- Eliminare: Rimuovere memorie obsolete o errate
- Forçando a criação: Você pode pedir explicitamente ao Copilot para lembrar de algo
// 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 Indexação de repositório é o motor que alimenta a compreensão código profundo do Copilot. Quando um repositório é indexado, O Copilot cria uma representação semântica do código que permite entender não apenas a estrutura dos arquivos, mas também o relacionamentos lógicos entre os componentes, o vícios entre os módulos e o fluxo de dados através do sistema.
Indicizzazione Automatica
A indexação acontece automaticamente a primeira vez que um usuário iniciar uma conversa do Copilot Chat em um repositório. Nenhum é necessário configuração ou ação manual. Quando a indexação for concluída, todos Os usuários do Copilot que acessam esse repositório se beneficiam do índice compartilhado.
Detalhes de indexação
| Aspetto | Detalhe |
|---|---|
| Trigger | Automático na primeira conversa do Copilot no repositório |
| Velocita' | Menos de 60 segundos para a maioria dos repositórios |
| Aggiornamento | Incremental a cada push (somente arquivos modificados) |
| Condivisione | O índice é compartilhado entre todos os usuários do Copilot do repositório |
| Privacy | O índice não é usado para treinar modelos de IA |
| Dimensione | Suporta repositórios de até milhões de linhas de código |
| Linguaggi | Todos os idiomas suportados pelo GitHub |
| Branch | A indexação cobre o branch padrão (principal/mestre) |
O que é indexado
A indexação vai muito além de um simples índice de pesquisa de texto. O sistema cria um entendimento semântica algum código que inclui:
Níveis de indexação
| Livello | O que analisa | Beneficio |
|---|---|---|
| Estrutura de arquivo | Organização de pastas, convenção de nomenclatura, padrão de projeto | Copilot entende onde procurar cada tipo de ativo |
| Definizioni | Classi, interfacce, funzioni, tipi, costanti | Sugestões precisas para tipos de métodos e assinaturas |
| Relazioni | Import/export, ereditarieta', composizione, dipendenze | Compreende o impacto das alterações em outros arquivos |
| Pattern | Padrões arquitetônicos recorrentes, convenções de codificação | Gere código consistente com os padrões existentes |
| Logica | Fluxo de dados, tratamento de erros, transformações | Sugere implementações que se integram à lógica existente |
| Documentação | Commenti, JSDoc, README, markdown | Use a documentação para entender a intenção do código |
| Test | Test case, assertion, mock, fixture | Gere testes consistentes com a estratégia de testes do projeto |
| Configuração | Config file, environment, build settings | Compreende o ambiente e as dependências do projeto |
Velocidade de indexação
Uma das inovações mais significativas é a redução de tempo indexação inferior a 60 segundos. Nas versões anteriores, a indexação pode levar minutos ou até horas para repositórios grandes. Hoje, obrigado para otimizações no algoritmo de incorporação e infraestrutura de indexação, a pesquisa semântica está disponível quase instantaneamente.
Após a indexação inicial, as atualizações são incremental: quando você envia novos commits, apenas os arquivos modificados são reindexados, mantendo o índice é sempre atualizado sem exigir uma reindexação completa.
Impacto na qualidade das respostas
A Indexação de Repositórios tem um impacto direto e mensurável na qualidade do O copiloto responde. Sem indexação, o Copilot só pode ver arquivos atualmente aberto no editor. Com a indexação, ele tem acesso a todo o base de código.
Exemplo de impacto
| Domanda | Sem indexação | Com indexação |
|---|---|---|
| “Como o projeto lida com a autenticação?” | Resposta genérica baseada nas melhores práticas | Resposta específica descrevendo middleware JWT, serviço de autenticação e guardas |
| "Criar um novo endpoint de pagamentos" | Endpoint genérico sem contexto | Endpoint que segue padrões de projeto, com middleware, validação e erros consistentes |
| "Por que o teste X falha?" | Analisi limitata al file del test | Análise incluindo o serviço em teste, dependências e simulações necessárias |
| "Quais arquivos preciso editar para adicionar um campo ao modelo Usuário?" | Apenas o arquivo de modelo | Modello, migration, DTO, validazione, serializer, test, docs |
Enterprise Controls
Para organizações, a Indexação de Repositório oferece controles granulares para gerenciar quais conteúdos são indexados e quais são excluídos. Isto é particularmente importante para repositórios que contêm código confidencial ou informações proprietárias.
# 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
**/*.dumpSinergia entre Espaços, Memória e Indexação
O verdadeiro poder destas três ferramentas emerge quando elas trabalham juntas. Cada cobre um aspecto diferente do problema de contexto e, juntos, fornecem ao Copilot uma compreensão completa e persistente do projeto.
Como os três sistemas colaboram
| Strumento | Tipo de Contexto | Persistenza | Scope |
|---|---|---|---|
| Repository Indexing | Struttura e relazioni del codice | Permanente (aggiornamento incrementale) | Intero repository |
| Copilot Spaces | Contexto de múltiplas fontes com curadoria do usuário | Persistente (gerenciado pelo usuário) | Multi-repository |
| Agentic Memory | Conhecimento inferido de interações | 28 giorni (rinnovabile) | Repository specifico |
Basicamente, quando você faz uma pergunta ao Copilot:
- Indexação de repositório recupera arquivos relevantes e estruturas de código
- Espaços adiciona contexto adicional (problema, relações públicas, documentação, notas)
- Memória Agente aplica as convenções e preferências aprendidas nas sessões anteriores
- Todos esses contextos são combinados e enviados ao modelo para gerar a resposta
Esempi Pratici
Vamos ver como essas ferramentas se aplicam aos cenários de trabalho diários.
Exemplo 1: Espaço de configuração para projeto 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)Exemplo 2: Usando a memória para convenções
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 NECESSARIAExemplo 3: Indexação de Repositório para Exploração de Código
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/ (entita' 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]Configuração avançada
Para aproveitar ao máximo essas ferramentas, é importante configurá-las corretamente com base nas necessidades do projeto e da equipe.
File .copilot-instructions.md
O arquivo .copilot-instructions.md na raiz do repositório vem
incluído automaticamente no contexto de cada conversa do Copilot. É a melhor maneira
direcionado para fornecer instruções persistentes ao Copilot para um repositório específico.
# 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 entita' (campo deletedAt)
- Audit trail per ogni operazione CRUD (campo createdBy, updatedBy)Ottimizzare l'Indicizzazione
Para melhorar a qualidade da indexação e o desempenho da pesquisa semântica, siga estas diretrizes:
Melhorar a qualidade
- Mantenha uma estrutura de pastas clara e consistente
- Use JSDoc/TSDoc para documentar funções e classes
- Escreva comentários significativos para lógica complexa
- Mantenha os READMEs atualizados para cada módulo
- Use nomes amigáveis para arquivos, classes e funções
- Documente relacionamentos entre módulos em arquivos README
Reduzir o ruído
- Excluir arquivos gerados com .copilotignore
- Exclua dependências desnecessárias de fornecedores
- Exclua arquivos de dados grandes (CSV, dumps)
- Excluir código legado que não é mais usado
- Exclua arquivos de bloqueio (package-lock.json é útil, yarn.lock nem tanto)
- Escludi asset binari (immagini, font, video)
Comparação com abordagens alternativas
Para contextualizar Espaços, Memória e Indexação, é útil compará-los com abordagens alternativas para fornecer contexto à IA.
Confronto Approcci al Contesto
| Approccio | Pro | Contro | Quando usar |
|---|---|---|---|
| Arquivos abertos no editor | Semplice, immediato | Contesto limitato ai file aperti | Modifiche locali a pochi file |
| #file mentions in chat | Controllo preciso | Manual, requer conhecimento de arquivos | Perguntas sobre arquivos específicos |
| Repository Indexing | Automático, completo | Somente código do repositório | Sempre (ativado por padrão) |
| Copilot Spaces | Multi-repo, multi-formato | Requer configuração inicial | Progetti complessi, multi-repo |
| Agentic Memory | Automatico, persistente | Limitado a 28 dias, para recompra | Convenzioni ricorrenti, pattern |
| .copilot-instructions.md | Persistente, condiviso col team | Somente texto, não dinâmico | Regras e convenções do projeto |
| Prompt manuale dettagliato | Massimo controllo | Não persistente, repetitivo | Task specifici e complessi |
Limitazioni e Considerazioni
Apesar das vantagens óbvias, é importante conhecer as limitações atuais dessas ferramentas para usá-las com expectativas realistas.
Limitazioni Attuali
| Strumento | Limitazione | Impatto | Mitigazione |
|---|---|---|---|
| Spaces | Não suporta atualização automática de conteúdo | Risco de contexto desatualizado | Revisão periódica do espaço |
| Spaces | Limite no número de repositórios por espaço | Projetos muito distribuídos podem não caber em um único Espaço | Crie espaços temáticos menores |
| Memory | Expiração de 28 dias para memórias não utilizadas | Conhecimento perdido se não for reutilizado | Use .copilot-instructions.md para informações permanentes |
| Memory | Scope limitato a singolo repository | Não transfere conhecimento entre repositórios do mesmo projeto | Use Spaces para contexto entre repositórios |
| Memory | Disponível apenas nos planos Pro e Pro+ | Não acessível para planos empresariais gratuitos e básicos | Use arquivos de instruções como alternativa |
| Indexing | Somente ramificação padrão indexada | Os recursos da filial não se beneficiam da indexação | Fusões frequentes no branch principal |
| Indexing | Arquivos excluídos de .gitignore não indexados | Configurações locais fora do contexto | Incluir arquivos de amostra no repositório |
| Tutti | Eles dependem da qualidade do código e da documentação | Repository mal documentati beneficiano meno | Investire in documentazione e commenti |
Privacidade e segurança de dados
Um aspecto importante a considerar, especialmente para equipes empresariais, diz respeito a privacidade e segurança dos dados utilizados por essas ferramentas.
Garantias de privacidade
- Sem treinamento: Os dados de espaços, memória e indexação não são usados para treinar modelos de IA
- Isolamento: As memórias são isoladas por usuário e por repositório
- Criptografia: Os dados são criptografados em trânsito e em repouso
- Controle do usuário: O usuário pode excluir todas as memórias e dados a qualquer momento
- Exclusão de conteúdo: Sua organização pode excluir arquivos e repositórios da indexação
- Conformidade: Os dados são processados de acordo com os termos de serviço do GitHub
- Residência dos dados: Para planos empresariais, os dados podem ser localizados em regiões específicas
Conclusão
Espaços Copiloto, Memória Agente e Indexação de Repositório representam um salto qualitativo na forma como fornecemos contexto para ferramentas de IA de desenvolvimento. Em vez de repetir as mesmas informações em cada sessão, podemos construir um ecossistema de contexto persistente que cresce e enriquece com o tempo.
A combinação destas três ferramentas abrange todos os aspectos do contexto: o código (Indexação de Repositório), le informação externa (Espaços) e o conhecimento implícito (Memória). Juntos, eles transformam Copiloto de assistente genérico a parceiro que conhece seu projeto, suas convenções e preferências.
Um conselho prático é: comece com a Indexação de Repositório (automática), adicione um
arquivos .copilot-instructions.md com as convenções do projeto e, em seguida, criar
Espaços para os contextos mais complexos. A memória aumentará naturalmente com o tempo
através de suas interações diárias.
Progresso da série
| # | Artigo | Status |
|---|---|---|
| 1 | Fundamentos e Mindset | Concluído |
| 2 | Ideação e Requisitos | Concluído |
| 3 | Arquitetura Backend | Concluído |
| 4 | Estrutura Frontend | Concluído |
| 5 | Prompt Engineering | Concluído |
| 6 | Testes e Qualidade | Concluído |
| 7 | Documentação | Concluído |
| 8 | Deploy e DevOps | Concluído |
| 9 | Evolução e Manutenção | Concluído |
| 10 | Coding Agent | Concluído |
| 11 | Code Review | Concluído |
| 12 | Copilot Edits | Concluído |
| 13 | GitHub Spark | Concluído |
| 14 | Spaces e Memory | Sei qui |
| 15 | Modelos de IA in Copilot | Prossimo |
| 16 | Personalização | Prossimo |
| 17 | Enterprise | Prossimo |
| 18 | Extensions | Prossimo |
| 19 | Segurança e Compliance | Prossimo |