Anpassa GitHub Copilot-anpassningen

Den moderniserade GitHub Copilot är utbyggbar. Agenten tillhandahåller flera anpassningspunkter för att koda ditt teams uppgraderingsmönster, framtvinga kodningsstandarder under uppgraderingar och definiera nya uppgraderingsarbetsflöden.

Översikt över anpassningspunkter

Anpassa via chatt

Anpassa agentens beteende i realtid via naturlig konversation. Agenten tillämpar antingen din instruktion omedelbart eller bevarar den för scenario-instructions.md framtida bruk.

Redigera scenarioartefakter

När agenten kör en uppgradering skapas en arbetsyta i .github/upgrades/{scenarioId}/. Uppgraderingsmappen innehåller redigerbara artefakter som styr agentens beteende direkt.

scenario-instruktioner.md

Filen scenario-instructions.md är agentens beständiga minne för uppgraderingen. Agenten läser alltid in den här filen i kontext, så allt du skriver här påverkar direkt varje beslut som agenten fattar.

Lägg till avsnitt som dessa för att vägleda agenten:

## 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

Filen plan.md definierar aktiviteterna och deras omfång. Redigera plan.md till:

• Ändra ordning på aktiviteter för att ändra körningssekvensen.
• Lägg till uppgifter som agenten inte hade planerat för.
• Ta bort uppgifter som inte gäller.
• Lägg till anteckningar för att ge kontext för specifika uppgifter.

Enskilda aktivitetsfiler

Varje uppgift i tasks/{taskId}/task.md innehåller uppgiftsspecifikationen och arbetsanteckningarna. Redigera dessa filer för att:

• Förfina en uppgifts omfång.
• Lägg till domänspecifik kontext som agenten missade.
• Ange kodexempel för önskat resultat.

Skapa anpassade kunskaper

Färdigheter är den primära expansionspunkten för agenten. En färdighet är en Markdown-fil med en metadatarubrik som lär agenten hur man hanterar en specifik uppgradering, ett mönster eller en uppgift.

Var du kan placera anpassade färdigheter

Färdighetsfilstruktur

Varje kunskapsfil har två delar: ett metadatahuvud (som agenten använder för att förstå när kunskapen gäller) och en Markdown-brödtext (instruktioner som agenten följer).

---
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

Metadatafält

Bästa praxis för utarbetande av färdigheter

• Var specifik i beskrivningen: Inkludera exakta paketnamn, biblioteksnamn och utlösarfraser på naturligt språk som användare kan skriva.
• Inkludera tydliga, stegvisa arbetsflöden: Numrera stegen. Var tydlig med vilka filer som ska ändras och vilka kommandon som ska köras.
• Inkludera framgångskriterier: Utan framgångskriterier vet inte agenten när den ska sluta. Använd kryssrutor eller en tydlig lista över verifierbara villkor.
• Inkludera felhantering: Förutse vanliga fellägen, till exempel saknade paket, byggfel eller brutna tester.
• Håll kunskaperna fokuserade: En färdighet per uppgradering eller uppgiftstyp. En färdighet för att "uppgradera FooBar v2 till v3" är bättre än att "uppgradera alla interna bibliotek".
• Namn med ett gerundverb: Använd upgrading-foobar-v2-to-v3, inte foobar-upgrade eller foobar-v3.
• Använd lazy identifiering: Använd lazy identifiering för de flesta anpassade färdigheter för att undvika att svälla upp agentens kontextfönster.

Skapa anpassade scenarier

För avancerade användare som vill definiera helt nya uppgraderingsarbetsflöden kan du med anpassade scenarier orkestrera en fullständig uppgraderingspipeline för flera faser. Ett scenario är en färdighet med metadata.discovery: scenario som definierar de faser som agenten följer.

---
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

Placera scenariofiler i .github/skills/ eller .github/upgrades/skills/ så att agenten kan identifiera dem.

Källkontroll och förgrening

Agenten erbjuder sig att arbeta på en Git-gren, men du har fullständig kontroll över strategin:

• Namngivning av gren: Tala om för agenten vilket grennamn som ska användas, eller låt agenten föreslå ett.
• Grenar per aktivitet: Begär en separat gren per aktivitet för detaljerad granskning.
• Tidsinställning för incheckning: Välj när agenten checkar in: efter varje slutförd uppgift (standard), endast i slutet av den fullständiga uppgraderingen eller på begäran.
• Ingen källkontroll: Agenten fungerar också med icke-Git-mappar, men rekommenderar att du säkerhetskopierar projektet först.

Exempel på chattinstruktioner:

• "Använd grennamnet "upgrade/dotnet10" för den här uppgraderingen"
• "Skapa en gren per aktivitet så att jag kan granska var och en separat"
• "Checka inte in förrän jag uttryckligen ber dig att göra det"
• "Checka in efter varje uppgift med ett beskrivande meddelande"

Prioritet för färdighetsladdning

När agenten upptäcker flera kunskaper löser den dem med hjälp av ett prioritetssystem. Källor med högre prioritet åsidosätter eller kompletterar källor med lägre prioritet:

Agenten samlar in kunskaper från alla källor. När kunskaper har överlappande omfång har källor med högre prioritet företräde. Fältet discovery styr när färdigheten läses in. lazy innebär på begäran när det är relevant och preload innebär alltid tillgängligt.

Relaterat innehåll

• Centrala begrepp
• Referens för scenarier och färdigheter
• Tillämpa anpassade uppgraderingsinstruktioner
• Bästa praxis