Cursor-integrasjon

Archgate integreres med Cursor for å gi AI-agenter en strukturert styringsarbeidsflyt. Agenten leser ADR-ene dine før den skriver kode, validerer etterpå, og fanger opp nye mønstre for teamet — den samme arbeidsflyten som er tilgjengelig i Claude Code-pluginet.

Oppsett

Kjør archgate init med --editor cursor-flagget for å konfigurere Cursor-integrasjon i prosjektet ditt:

archgate init --editor cursor

Med plugin (beta)

Betatilgang kreves

Cursor-pluginet er for øyeblikket i beta. Kjør archgate login for å registrere deg og autentisere.

Hvis du har logget inn via archgate login, installerer init-kommandoen også Archgate-pluginet for Cursor. Pluginet tilbyr ferdigbygde agentregler og ferdigheter som gir Cursor sin AI-agent en komplett styringsarbeidsflyt.

Pluginet distribueres på to måter:

1. Cursor Team Marketplace — Pluginet publiseres til et git-basert team-markedsplass-repositorium. Etter installasjon oppdager Cursor det fra team-markedsplassens URL som skrives ut av CLI-en.
2. VS Code Extension (VSIX) — En .vsix-utvidelse installeres i Cursor via cursor --install-extension-kommandoen.

For å eksplisitt installere pluginet:

archgate login              # engangsoppsett
archgate init --editor cursor --install-plugin

Kommandoen archgate plugin install --editor cursor installerer VS Code-utvidelsen via cursor-CLI-en hvis tilgjengelig og skriver ut team-markedsplassens URL; ellers skrives manuelle instruksjoner ut.

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

archgate plugin install --editor cursor

Uten plugin (gratis)

Uten pluginet konfigurerer archgate init --editor cursor fortsatt en grunnleggende styringsregel. AI-agenten kan konsultere ADR-er og kjøre sjekker via CLI-kommandoer, men får ikke de rollebaserte ferdighetene beskrevet nedenfor.

Genererte filer

| Fil | Formål | | --------------------------------------- | -------------------------------------------------------------------- | | .cursor/rules/archgate-governance.mdc | Alltid-på Cursor-regel som instruerer agenten om å konsultere ADR-er |

Hva pluginet tilbyr

Pluginet legger til en agent og rollebaserte ferdigheter i Cursor. Cursors plugin-system håndterer navnerom, så ferdigheter bruker sine direkte navn uten prefiks.

Agent

| Navn | Formål | | ----------- | ------------------------------------------------------------------------- | | developer | Generell utviklingsagent som leser ADR-er før koding og validerer etterpå |

developer-agenten orkestrerer ferdighetene nedenfor automatisk som en del av arbeidsflyten.

Ferdigheter

| Navn | Formål | | ----------------- | --------------------------------------------------------------------------------------- | | architect | Validerer kodeendringer mot alle prosjektets ADR-er for strukturell samsvar | | quality-manager | Gjennomgår regeldekning og foreslår nye ADR-er når mønstre dukker opp | | adr-author | Oppretter og redigerer ADR-er i henhold til prosjektets konvensjoner | | onboard | Engangsoppsett: utforsker kodebasen, intervjuer utvikleren, oppretter innledende ADR-er | | cli-reference | Intern referanse for AI-agenter med den komplette Archgate CLI-kommandoguiden |

Disse er den samme agenten og ferdighetene som er tilgjengelige i Claude Code-pluginet (archgate:developer, archgate:architect, osv.), tilpasset Cursors plugin-system.

Første oppsett med onboard

Etter å ha installert pluginet, kjør 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

Med pluginet

developer-agenten følger en strukturert arbeidsflyt for hver kodeoppgave:

1. Les gjeldende ADR-er — Agenten kjører archgate review-context for å se hvilke ADR-er som gjelder for filene som endres. Den skriver ikke kode før den har lest de gjeldende ADR-ene.

2. Skriv kode i henhold til ADR-begrensninger — Agenten implementerer endringer i henhold til Do’s and Don’ts fra de gjeldende ADR-ene.

3. Kjør samsvarssjekker — Agenten kjører archgate check --staged for å utføre automatiserte regler. Eventuelle brudd utbedres før man går videre.

4. Arkitektgjennomgang — Agenten aktiverer architect-ferdigheten for å validere strukturelt ADR-samsvar utover det automatiserte regler fanger opp.

5. Fang opp læringer — Agenten aktiverer quality-manager-ferdigheten for å gjennomgå arbeidet og identifisere mønstre som er verdt å fange opp som nye ADR-er eller oppdateringer til eksisterende.

Uten pluginet

Agenten bruker styringsregelen og CLI-kommandoer for å følge fire manuelle trinn:

1. Gjennomgå kontekst — Kjør archgate review-context for å se hvilke ADR-er som gjelder for filene som endres.

2. Les individuelle ADR-er — For full kontekst om en spesifikk beslutning, kjør archgate adr show <id> (for eksempel archgate adr show ARCH-001).

3. Skriv kode — Implementer endringer i henhold til begrensningene fra de gjeldende ADR-ene.

4. Kjør samsvarssjekker — Kjør archgate check --staged for å validere at koden samsvarer med alle ADR-regler.

ADR-drevet avvisning

Når agenten møter en oppgave som ville kreve brudd på en ADR, avviser den og forklarer hvilken ADR som ville bli brutt. Den foreslår deretter hvordan man kan oppnå det samme målet uten å bryte reglene.

Hvis for eksempel en utvikler ber agenten om å legge til chalk som en avhengighet i et prosjekt styrt av en ADR for avhengighetspolicy, vil agenten:

1. Avvise, med henvisning til ADR-en og den godkjente avhengighetslisten
2. Foreslå det godkjente alternativet i stedet
3. Tilby å implementere oppgaven med den samsvarende tilnærmingen

Denne oppførselen er konsistent uavhengig av hvordan utvikleren formulerer forespørselen. ADR-er behandles som obligatoriske begrensninger, ikke forslag.

Når du skal bruke hver agent eller ferdighet

| Scenario | Ferdighet | | ------------------------------------------------- | ----------------- | | Starte et nytt prosjekt med Archgate | onboard | | Daglige kodeoppgaver | developer | | Gjennomgå en PR for ADR-samsvar | architect | | Oppdage et gjentagende mønster verdt å kodifisere | quality-manager | | Opprette eller redigere en ADR | adr-author |

developer-agenten orkestrerer ferdighetene automatisk — den aktiverer architect og quality-manager som en del av arbeidsflyten. Mesteparten av tiden trenger du bare å bruke developer direkte.

Styringsregel

Styringsregelen i .cursor/rules/archgate-governance.mdc bruker alwaysApply: true, noe som betyr at Cursor-agenten alltid har styringstilgang tilgjengelig uten manuell aktivering. Den instruerer agenten om å kjøre archgate review-context før koding og archgate check --staged etterpå.

Tilgang til sesjonsutskrifter

Kommandoen archgate session-context cursor leser Cursor-agentens sesjonsutskrifter fra disk. Dette lar ferdigheter få tilgang til historikken til den gjeldende samtalen, noe som er nyttig for å gjenopprette kontekst som kan ha blitt komprimert eller avkortet.

Kommandoen aksepterer to valgfrie flagg:

• --max-entries <n> — Maksimalt antall oppføringer å returnere (standard: 200, nyeste oppføringer).
• --session-id <uuid> — En spesifikk sesjons-UUID å lese. Hvis utelatt, brukes den nyeste sesjonen.

Tips for effektiv bruk

• Bruk developer-ferdigheten for kodeoppgaver. Den orkestrerer hele les-valider-fang-opp-arbeidsflyten automatisk.
• Kjør onboard en gang per prosjekt. Den setter opp de innledende ADR-ene basert på den faktiske kodebasen og konvensjonene dine.
• Bruk architect for PR-gjennomganger. Den validerer strukturelt samsvar utover det automatiserte regler fanger opp.
• Bruk quality-manager etter å ha løst vanskelige problemer. Den fanger opp læringer slik at de samme feilene ikke gjentas.
• Commit .cursor/-mappen. Dette sikrer at alle teammedlemmer får den samme styringskonfigurasjonen når de kloner repositoriet.
• Hold ADR-regelfiler oppdatert. Agenten håndterer det reglene sjekker for — hvis en regel mangler, vil bruddet ikke bli fanget opp.