---
title: VS Code-plugin
description: Installer Archgate VS Code-utvidelsen for AI-assistert utvikling med arkitektur-guardrails. Sanntids ADR-samsvarskontroll i editoren din.
---

Archgate VS Code-pluginet gir AI-agenter som jobber i [VS Code](https://code.visualstudio.com/) innebygde guardrails. Agenter leser ADR-ene dine før de skriver kode, validerer etterpå, og fanger opp nye mønstre for teamet -- den samme arbeidsflyten som er tilgjengelig i [Claude Code-pluginet](/guides/claude-code-plugin/).

## Hvordan det fungerer

VS Code støtter **agent-plugins** installert fra git-baserte markedsplasser. Archgate-pluginet serveres fra et git-repositorium på `plugins.archgate.dev/archgate/vscode.git`. Når du legger til denne markedsplassen i VS Code-brukerinnstillingene dine, oppdager og installerer VS Code pluginet automatisk.

Pluginet serveres i VS Code Copilots opprinnelige `.github/plugin/`-manifestformat, adskilt fra Claude Code `.claude-plugin/`-formatet.

## Installasjon

:::caution[Krav til VS Code-versjon]
Agent-plugins krever **VS Code 1.110 (februar 2026-utgivelsen) eller nyere**. Tidligere versjoner støtter ikke git-baserte agent-plugin-markedsplasser. Sjekk versjonen din med `code --version`.
:::

:::note[Betatilgang kreves]
VS Code-pluginet er for øyeblikket i beta. Kjør `archgate login` for å logge inn før du følger trinnene nedenfor.
:::

### 1. Logg inn på Archgate-plattformen

Logg inn for å få tilgang til pluginene:

```bash
archgate login
```

Dette starter en OAuth 2.0 Device Authorization Grant mot Archgate-plattformen. CLI-en viser en engangskode og URL -- åpne URL-en i nettleseren din, skriv inn koden, og autoriser. Når det er fullført, gis tokenene til den git credential-helperen du har konfigurert via `git credential approve`; en helper som bruker operativsystemet holder dem krypterte, mens gits innebygde `store`-helper skriver dem i klartekst.

### 2. Initialiser prosjektet ditt med pluginet

Kjør `archgate init` med `--editor vscode`-flagget:

```bash
archgate init --editor vscode
```

Hvis du allerede er logget inn, vil denne kommandoen:

1. Opprette `.archgate/`-mappen med ADR-er og lint-regler
2. Legge til markedsplassens URL i VS Code-**brukerinnstillingene** dine

`archgate init` laster ikke ned VS Code-utvidelsen. For å installere selve utvidelsen, kjør `archgate plugin install --editor vscode` (se nedenfor).

Innstillingen `chat.plugins.marketplaces` er applikasjonsscopet i VS Code, så den kan ikke settes per arbeidsområde. CLI-en skriver den automatisk til `settings.json` på brukernivå:

| Plattform | Sti til brukerinnstillinger                                |
| --------- | ---------------------------------------------------------- |
| Windows   | `%APPDATA%\Code\User\settings.json`                        |
| macOS     | `~/Library/Application Support/Code/User/settings.json`    |
| Linux     | `~/.config/Code/User/settings.json`                        |
| WSL       | Stien på Windows-siden ovenfor (VS Code kjører på Windows) |

### 3. Installer utvidelsen

For å installere eller reinstallere utvidelsen på et allerede initialisert prosjekt:

```bash
archgate plugin install --editor vscode
```

Uten `--editor` oppdager en interaktiv kjøring hvilke editorer som er installert på maskinen din og lar deg velge; en ikke-interaktiv kjøring (en agent eller CI) faller tilbake til Claude Code.

Dette skriver markedsplassens URL på nytt inn i brukerinnstillingene dine, og når `code`-CLI-en er på PATH, laster den ned Archgate VS Code-utvidelsen fra plugins-tjenesten og installerer den via `code --install-extension`. Hvis `code`-CLI-en ikke er tilgjengelig, skrives instruksjoner for manuell installasjon ut. Hvis selve installasjonen feiler, beholdes den nedlastede `.vsix`-filen på `~/.archgate/archgate.vsix` slik at du kan installere den for hånd.

### Genererte filer

Kommandoene oppretter eller oppdaterer følgende:

| Fil                    | Omfang      | Formål                                                                |
| ---------------------- | ----------- | --------------------------------------------------------------------- |
| Bruker `settings.json` | Bruker      | `chat.plugins.marketplaces` med Archgate-markedsplassens URL (`init`) |
| Archgate-utvidelse     | Applikasjon | VS Code-utvidelse installert via `.vsix` (`archgate plugin install`)  |

Brukerinnstillingsfilen flettes additivt -- eksisterende innstillinger overskrives aldri. VS Codes innebygde standardmarkedsplasser (`github/copilot-plugins`, `github/awesome-copilot`) bevares når nøkkelen settes for første gang.

Markedsplassinnstillingen på brukernivå (lagt til i `settings.json`):

```json
{
  "chat.plugins.marketplaces": [
    "https://plugins.archgate.dev/archgate/vscode.git"
  ]
}
```

URL-en inneholder ingen legitimasjon. `archgate credential` er credential-helperen; `archgate login` registrerer den for `plugins.archgate.dev`. Git spør den ved hver forespørsel og får et gyldig tilgangstoken, fornyet bare når det mellomlagrede har utløpt.

### Manuelt oppsett

Hvis du foretrekker at CLI-en ikke endrer brukerinnstillingene dine, kan du sette opp ting manuelt:

**Markedsplassens URL:** Åpne VS Codes brukerinnstillinger-JSON (`Ctrl+Shift+P` -> "Preferences: Open User Settings (JSON)") og legg til `chat.plugins.marketplaces`-oppføringen vist ovenfor. Du kan skrive ut URL-en ved å kjøre `archgate plugin url --editor vscode`.

**Utvidelse:** Last ned og installer `.vsix`-filen direkte:

```bash
printf 'protocol=https\nhost=plugins.archgate.dev\n\n' |
  archgate credential get |
  sed -n 's|^password=\(.*\)|header = "Authorization: Bearer \1"|p' |
  curl --config - --fail --silent --show-error --output archgate.vsix https://plugins.archgate.dev/api/vscode &&
  code --install-extension archgate.vsix
rm -f archgate.vsix
```

`archgate credential get` skriver ut et git credential-svar, så `password=`-linjen formes om til et `curl --config`-direktiv og sendes inn via pipe. Tokenet havner aldri på kommandolinjen, der det ville vært synlig i prosesslisten og i shell-historikken. `--fail` gjør at curl avslutter med feilkode ved 401 i stedet for å skrive feilmeldingen over `archgate.vsix`, og `&&` hindrer `code` i å installere noe curl ikke lastet ferdig; den avsluttende `rm -f` rydder opp uansett.

Bruk heller marketplace-oppsettet over når du kan: da spør git helperen ved hver forespørsel, og du håndterer ikke noe token manuelt.

## Hva pluginet tilbyr

Pluginet legger til agenter og rollebaserte ferdigheter i VS Codes AI. Utvikleragenten orkestrerer guardrails-arbeidsflyten og aktiverer ferdigheter etter behov.

### Agenter

| Agent                | Formål                                                                               |
| -------------------- | ------------------------------------------------------------------------------------ |
| `archgate:developer` | Generell utviklingsagent som leser ADR-er før koding og validerer etterpå            |
| `archgate:planner`   | Planleggingsagent for å avgrense arbeid og bryte oppgaver ned i ADR-samsvarende steg |

`archgate:developer`-agenten er satt som standardagent via plugin-innstillingene. Den orkestrerer ferdighetene nedenfor automatisk som en del av arbeidsflyten.

### Ferdigheter

| Ferdighet                  | Formål                                                                                  |
| -------------------------- | --------------------------------------------------------------------------------------- |
| `archgate:reviewer`        | Validerer kodeendringer mot alle prosjektets ADR-er for strukturelt samsvar             |
| `archgate:lessons-learned` | Fanger opp lærdommer og foreslår nye ADR-er når mønstre dukker opp                      |
| `archgate:adr-author`      | Oppretter og redigerer ADR-er i henhold til prosjektets konvensjoner                    |
| `archgate:onboard`         | Engangsoppsett: utforsker kodebasen, intervjuer utvikleren, oppretter innledende ADR-er |
| `archgate:cli-reference`   | Intern referanse for AI-agenter med den komplette kommandoguiden for Archgate CLI       |

## Første oppsett med onboard

Etter installasjon, kjør `archgate:onboard`-ferdigheten i prosjektet ditt en gang. Denne ferdigheten:

1. Utforsker kodebasestrukturen din (mapper, nøkkelfiler, pakkekonfigurasjon)
2. Intervjuer deg om teamets konvensjoner, begrensninger og arkitekturbeslutninger
3. Oppretter et innledende sett med ADR-er basert på svarene dine
4. Setter opp `.archgate/`-mappen med de første reglene dine

Onboard-ferdigheten er designet for å kjøres en gang per prosjekt. Etter onboarding håndterer de andre ferdighetene daglig utvikling.

## Hvordan det fungerer i praksis

Pluginet følger en strukturert arbeidsflyt for hver kodeoppgave:

### 1. Les gjeldende ADR-er

Når utvikleren gir en kodeoppgave, kjører agenten `archgate review-context` for å lese alle ADR-er som gjelder for filene som endres. Dette gir en komprimert briefing med **Decision**- og **Do's and Don'ts**-seksjonene fra hver relevante ADR.

### 2. Skriv kode i henhold til ADR-begrensninger

Agenten skriver kode som samsvarer med begrensningene fra ADR-ene. Do's and Don'ts-seksjonene fungerer som konkrete retningslinjer.

### 3. Valider endringer

Etter å ha skrevet kode, kjører agenten `archgate check` for å utføre automatiserte regler mot endringene. Eventuelle brudd utbedres før man går videre.

### 4. Gjennomgå endringer

Agenten aktiverer `archgate:reviewer` for å validere strukturelt ADR-samsvar utover det automatiserte regler fanger opp.

### 5. Fang opp læringer

Agenten aktiverer `archgate:lessons-learned` for å gjennomgå arbeidet og identifisere mønstre som er verdt å fange opp som nye ADR-er.

## Tips

- **Hver utvikler kjører `archgate init --editor vscode`** etter `archgate login` for å konfigurere markedsplassens URL på brukernivå, deretter `archgate plugin install --editor vscode` for å installere utvidelsen.
- **Kjør onboard en gang per prosjekt** for å generere de innledende ADR-ene fra den faktiske kodebasen din.
- **Hold ADR-regelfiler oppdatert** -- agenten håndterer det reglene sjekker for.