Personalizar a modernização do GitHub Copilot

A modernização do GitHub Copilot é expandível. O agente fornece múltiplos pontos de personalização para codificar os padrões de atualização da sua equipa, impor padrões de codificação durante as atualizações e definir novos fluxos de trabalho de atualização.

Visão geral dos pontos de personalização

Personaliza através do chat

Personalize o comportamento do agente em tempo real através de uma conversa natural. O agente aplica a sua instrução imediatamente ou guarda-a em scenario-instructions.md para referência futura.

Editar artefactos do cenário

Quando o agente executa uma atualização, cria um espaço de trabalho em .github/upgrades/{scenarioId}/. A pasta de atualização contém artefactos editáveis que controlam diretamente o comportamento do agente.

scenario-instructions.md

O scenario-instructions.md ficheiro é a memória persistente do agente para a atualização. O agente carrega sempre este ficheiro no contexto, por isso tudo o que escreves aqui influencia diretamente cada decisão que o agente toma.

Adicione secções como estas para orientar o agente:

## User Preferences

### Technical Preferences
- Always prefer explicit type declarations over `var`
- Use `ILogger<T>` instead of `ILoggerFactory` for dependency injection
- Target .NET 10 for all projects
- Keep Newtonsoft.Json in the shared library (don't migrate to System.Text.Json)

### Execution Style
- **Pace**: Methodical
- **Pause Points**: After assessment, after each task group

### Custom Instructions

#### 02-common-lib
- Skip the database migration for now — it has external dependencies
- Use the connection string from `appsettings.Production.json` for testing

#### 03-data-layer
- Keep existing repository interfaces during migration
- Preserve all Entity Framework conventions

## Key Decisions Log
- 2025-01-15: Keep Newtonsoft.Json in SharedLib — third-party SDK requires it
- 2025-01-16: Skip database project — DBA team will handle separately

plan.md

O plan.md ficheiro define as tarefas e o seu âmbito. Edit plan.md para:

• Reordenar as tarefas para alterar a sequência de execução.
• Adicionar tarefas que o agente não planeou.
• Remove tarefas que não se aplicam.
• Adicione notas para contextualizar tarefas específicas.

Ficheiros individuais de tarefas

Cada tarefa em tasks/{taskId}/task.md contém a especificação da tarefa e notas de trabalho. Editar estes ficheiros para:

• Refinar o âmbito de uma tarefa.
• Adicione o contexto específico do domínio que o agente não considerou.
• Forneça exemplos de código para o resultado desejado.

Criar competências personalizadas

As competências são o principal ponto de extensão para o agente. Uma skill é um ficheiro Markdown com um cabeçalho de metadados que ensina o agente a lidar com uma atualização, padrão ou tarefa específica.

Onde colocar competências personalizadas

Estrutura do ficheiro de habilidades

Cada ficheiro de competências tem duas partes: um cabeçalho de metadados (que o agente usa para compreender quando a competência se aplica) e um corpo em Markdown (instruções que o agente segue).

---
name: migrating-foobar-v2-to-v3
description: >
  Migrate our internal FooBar library from v2 to v3. Activates when
  FooBar.v2 NuGet package is detected, or when asked to "upgrade FooBar",
  "migrate FooBar", or "update FooBar library".
metadata:
  discovery: lazy
  traits: .NET | CSharp
---

# Migrating FooBar Library v2 to v3

## Overview

FooBar v3 introduces a new async-first API surface. This skill guides the
agent through replacing synchronous FooBar.v2 calls with their v3 async
equivalents, updating configuration, and verifying behavior.

## Workflow

1. **Identify FooBar.v2 references**
   - Search for `PackageReference` elements referencing `FooBar.v2`
   - Locate all `using FooBar.V2;` directives

2. **Update package references**
   - Replace `FooBar.v2` with `FooBar.v3` in all `.csproj` files
   - Run `dotnet restore` to verify resolution

3. **Migrate API calls**
   - Replace `FooBarClient.Send(...)` with `await FooBarClient.SendAsync(...)`
   - Replace `FooBarConfig.LoadFromFile(...)` with `FooBarConfig.LoadFromJsonAsync(...)`
   - Update method signatures to `async Task` where needed

4. **Update configuration**
   - Rename `foobar.config` to `foobar.json`
   - Migrate XML config entries to JSON format

5. **Verify**
   - Build the project: `dotnet build`
   - Run existing tests: `dotnet test`
   - Verify no remaining references to `FooBar.V2` namespace

## Success Criteria

- [ ] No references to `FooBar.v2` NuGet package remain
- [ ] All `FooBar.V2` namespace usages replaced with `FooBar.V3`
- [ ] Project builds without errors
- [ ] All existing tests pass

## Error Handling

- If `FooBar.v3` is not available in the configured NuGet feeds, instruct
  the user to add the internal feed
- If async migration causes deadlocks in legacy synchronous code paths,
  wrap calls with `.GetAwaiter().GetResult()` and add a TODO comment

Campos de metadados

Melhores práticas de criação de habilidades

• Seja específico na descrição: Inclua nomes exatos de embalagens, nomes de bibliotecas e frases de gatilho em linguagem natural que os utilizadores possam escrever.
• Inclua fluxos de trabalho claros e passo a passo: Numere os passos. Sê explícito sobre que ficheiros alterar e que comandos executar.
• Inclua critérios de sucesso: Sem critérios de sucesso, o agente não sabe quando parar. Use caixas de seleção ou uma lista clara de condições verificáveis.
• Inclua o tratamento de erros: Antecipe modos de falha comuns, como pacotes em falta, falhas na construção ou testes falhados.
• Mantém o foco nas competências: Uma habilidade por melhoria ou tipo de tarefa. Uma competência para "atualizar o FooBar v2 para v3" é melhor do que "atualizar todas as bibliotecas internas."
• Nome com verbo gerúndio: Use upgrading-foobar-v2-to-v3, não foobar-upgrade ou foobar-v3.
• Use lazy descoberta: Use lazy descoberta para a maioria das competências personalizadas para evitar sobrecarregar a janela de contexto do agente.

Criar cenários personalizados

Para utilizadores avançados que querem definir fluxos de trabalho de atualização totalmente novos, cenários personalizados permitem-lhe orquestrar um pipeline completo de atualizações em múltiplas fases. Um cenário é uma habilidade com metadata.discovery: scenario que define as fases que o agente deve seguir.

---
name: migrating-soap-to-rest-api
description: >
  Migrate legacy WCF/SOAP services to ASP.NET Core REST APIs. Activates
  when WCF service references, .svc files, or SOAP clients are detected,
  or when asked to "migrate SOAP to REST", "replace WCF", or "convert
  web services to REST".
metadata:
  discovery: scenario
  traits: .NET | CSharp
  scenarioTraitsSet: [wcf, soap, web-services]
---

# SOAP to REST API Migration

## Pre-initialization

Gather from the user:
- Which SOAP services to migrate (all or specific ones)
- Whether to maintain backward compatibility with a SOAP facade
- Authentication mechanism for the new REST APIs
- API versioning strategy (URL path, header, query string)

## Assessment

Analyze the solution for:
- `.svc` files and WCF service contracts
- WSDL files and service references
- `System.ServiceModel` usage and binding configurations
- Data contracts and their serialization requirements
- Client proxies consuming SOAP services

## Planning

Create tasks in this order:
1. Create shared DTOs — Convert `[DataContract]` types to POCOs
2. Create REST controllers — One controller per `[ServiceContract]`
3. Map operations to HTTP methods
4. Migrate service implementations
5. Update clients — Replace `ChannelFactory`/generated proxies with `HttpClient`
6. Remove WCF infrastructure
7. Add API documentation — Swagger/OpenAPI via Swashbuckle

## Execution

For each service contract:
1. Create a corresponding controller
2. Create a service interface and implementation
3. Register the service in DI
4. Map WCF operations to REST endpoints
5. Update any in-solution clients to use the new REST endpoints
6. Build and run existing tests

Coloque os ficheiros de cenários em .github/skills/ ou .github/upgrades/skills/ para o agente os descobrir.

Gestão de versões e ramificação

O agente oferece-se para trabalhar numa branch Git, mas tu tens controlo total sobre a estratégia:

• Nomenclatura das filiais: Diz ao agente qual o nome da agência a usar, ou deixa que o agente sugira um.
• Ramificações por tarefa: Solicite uma ramificação separada por tarefa para uma revisão detalhada.
• Tempo de confirmação: Escolha quando o agente confirma: após cada tarefa concluída (padrão), apenas no final da atualização completa, ou a pedido.
• Sem controlo de versão: O agente também trabalha com pastas que não são do Git, mas recomenda fazer backup do seu projeto primeiro.

Instruções de chat de exemplo:

• "Para esta atualização, use o nome da branch 'upgrade/dotnet10'"
• "Cria uma ramificação por tarefa para que eu possa rever cada uma separadamente"
• "Não te comprometas até eu te pedir explicitamente"
• "Fazer commit após cada tarefa com uma mensagem descritiva"

Prioridade de carregamento de habilidades

Quando o agente descobre múltiplas competências, resolve-as usando um sistema de prioridades. Fontes de prioridade superior sobrepõem-se ou complementam as de prioridade inferior:

O agente recolhe competências de todas as fontes. Quando as competências têm âmbito sobreposto, as fontes de maior prioridade têm prioridade. O campo discovery controla o momento em que a skill é carregada. lazy Significa a pedido quando relevante, e preload significa sempre disponível.

Conteúdo relacionado

• Conceitos fundamentais
• Cenários e referências de competências
• Aplicar instruções de atualização personalizadas
• Melhores práticas