AI-assistent¶

En assistent i redigeraren som styr den AI-kommandoradsagent du redan har installerad — förklara, omstrukturera, rätta, skriva tester, sammanfatta, översätta och chatta, där varje föreslagen ändring visas som en granskningsbar diff som du tillämpar med avsikt.

Ta med din egen agent¶

Assistenten ber dig inte om någon API-nyckel och loggar inte in dig någonstans. I stället kör den en lokalt installerad AI-CLI-agent som medhjälpare och låter dess utdata strömma in i redigeraren. Autentisering, din prenumeration och valet av modell hör alla till det verktyget.

I dag: Claude Code (claude) och Codex CLI (codex). Installera en av dem och logga in en gång (så att claude eller codex fungerar från en terminal); redigeraren plockar upp den automatiskt. Gemini erbjuds också, men dess kommandoradsintegration är ännu inte verifierad.
Identifieringen är automatisk och blockerar inget. Redigeraren letar efter agenten i bakgrunden strax efter start — fönstret väntar aldrig på den. Medan sökningen pågår är Visa → AI-chatt kort inaktiverad med verktygstipset Identifierar AI-motor…; några sekunder senare aktiveras den (agenten hittad) eller förblir gråtonad med en ledtråd om vad du behöver installera.

Agenten är ett separat program som du installerar

Redigeraren levererar ingen AI-agent och laddar inte ned någon, och den skickar inte din text någonstans själv — den CLI-agent du installerade utför begäran med sitt eget konto och sin egen nätverksanslutning. Är agenten inte installerad eller inloggad förblir AI-funktionerna helt enkelt avstängda och inget annat i redigeraren påverkas.

Krav¶

Assistenten har ett hårt krav: en AI-CLI-agent som stöds, installerad och inloggad i systemets PATH.

Installera en agent som stöds. I dag är det Claude Code (claude) eller Codex CLI (codex).
Logga in en gång. Kör agenten från en terminal och slutför dess egen inloggning, så att den fungerar utan skärm efteråt. Redigeraren ber aldrig om och lagrar aldrig någon API-nyckel — din prenumeration och din inloggning bor helt i det verktyget.
Se till att den finns i din PATH. Kan redigeraren inte köra den är Visa → AI-chatt gråtonad med ett förklarande verktygstips.

Panelen AI-chatt¶

Det finns ingen AI-meny på toppnivå — allt bor i en enda underpanel, som växlas från Visa → AI-chatt. Om panelen var öppen när du senast stängde redigeraren öppnas den igen vid nästa start (när motorn identifierats).

Uppifrån och ned visar panelen:

en rullgardinslista Motor (ditt val kommer ihåg mellan sessioner) och kryssrutan Tillåt filändringar (se nedan);
en statusrad — den identifierade motorn och versionen, en anteckning om sökning eller framsteg, eller ledtråden «installera och logga in». Efter det första svaret namnger den också den modell agenten verkligen använde, till exempel Engine: Claude (2.1.200) · claude-sonnet-5 — värd en blick, eftersom modellen avgör vad körningen kostar dig (se Välja modell);
ett smalt upptagetfält med en knapp Stoppa medan agenten arbetar;
konsolen — hela samtalet i en vy;
en ledtrådsrad som listar de tillgängliga kommandona som klickbara länkar.

Konsolen¶

Samtalet fungerar som en terminal: historiken ovanför, och du skriver i slutet, efter prompten ›.

Enter skickar; Shift+Enter infogar en radbrytning, så att frågor över flera rader fungerar.
Att klicka eller skriva var som helst i historiken flyttar markören tillbaka till prompten — historiken är markerbar och kopierbar men aldrig redigerbar.
Esc avbryter den pågående begäran; när inget pågår tömmer den det du skrivit efter ›. Esc fungerar med fokus var som helst i panelen.
Ctrl+A markerar bara den fråga du håller på att formulera, så att det du skriver härnäst ersätter den; med inget skrivet markerar den i stället hela utskriften, redo att kopieras.
Upp och Ned hämtar tillbaka det du frågat tidigare, som ett skal gör. Upp på den första raden av det du skriver kliver bakåt genom dina tidigare frågor; Ned går framåt igen, och att kliva förbi den nyaste lämnar tillbaka den halvskrivna rad du började från. Inuti en fråga över flera rader flyttar de helt enkelt mellan raderna, och när du redigerar en återhämtad fråga blir den ditt nya utkast. Historiken gäller per panel och bevaras inte mellan sessioner.
Medan ett svar strömmar in följer vyn med om du är längst ned; rulla upp för att läsa så stannar den kvar. När svaret är färdigt placerar vyn det med avsikt: ett kort svar rullar till botten så att du ser det och prompten under det, medan ett långt lägger sin rubrik Assistent i linje med panelens överkant så att du kan läsa från början.
Varje svars Markdown återges för sig, så att numrerade listor börjar på 1 varje gång i stället för att fortsätta det föregående svarets numrering.

Kommandon¶

Skriv ett kommando vid prompten, eller klicka på det i ledtrådsraden (kommandon som tar ett argument får ett efterföljande mellanslag och väntar på att du ska avsluta raden):

Kommando	Vad det gör	Resultat
`.explain`	Förklara den markerade koden	svar i chatten
`.summarize`	Sammanfatta den markerade texten	svar i chatten
`.refactor <how>`	Omstrukturera enligt anvisning (t.ex. `.refactor extract a helper`)	granskningsbar ändring
`.fix`	Rätta den markerade koden	granskningsbar ändring
`.tests`	Skriv enhetstester för markeringen	granskningsbar ändring
`.translate <language>`	Översätt markeringen (t.ex. `.translate German`)	granskningsbar ändring
`.model <id>`	Fäst den modell den här redigeraren ber om (se Välja modell)	besvaras direkt, ingen agentkörning

Allt annat du skriver hanteras naturligt:

Vanlig text är en fri fråga till agenten, skickad tillsammans med det du har på skärmen (se nedan).
En rad som börjar med / är ett av agentens egna kommandon (som Claudes /help) och vidarebefordras exakt som skrivet — inget av redigerarens läggs till, och inget samtycke behövs eftersom inget av ditt skickas. Detta gäller motorer vars kommandouppsättning har verifierats — i dag Claude; på de andra behandlas en /-rad som en vanlig fråga.
Ett okänt .ord är inget fel; det skickas vidare som en fråga.

Varje CLI-kommando betyder inte detsamma här som i agentens egen terminal: några kräver en interaktiv session som redigerarens körningar inte har, några rör samtal som redigeraren redan hanterar själv, och några — som /model — kan helt enkelt inte överleva en enda begäran. När du skickar ett sådant vidarebefordrar redigeraren det ändå och lägger till en kort anteckning om varför det kanske inte gör det du förväntar dig. Du ser varje anteckning en gång per session.

Agentens eget /model kan inte sitta kvar — använd .model

Varje fråga kör agenten på nytt, och en ny körning börjar alltid från den modell din CLI är konfigurerad att använda. /model … svarar «Modell satt till … endast för den här sessionen», men den sessionen är över i samma stund som svaret är det: nästa fråga — även en som fortsätter samma samtal — är tillbaka på den konfigurerade modellen. Använd .model <id> i stället; det är redigerarens eget kommando och fäster modellen för varje senare fråga. Se Välja modell.

Matchningen är oberoende av skiftläge, och ledtrådsraden smalnar av medan du skriver (.r → .refactor …).

Markering eller hela dokumentet¶

Kommandon arbetar på den aktuella markeringen. Utan markering arbetar de på hela dokumentet — och eftersom det skickar hela filen till agenten frågar redigeraren först: Skicka hela dokumentet '…' till Claude? Du tillfrågas en gång per dokument per redigerarsession; att neka avbryter sändningen och behåller det du skrivit. Frågan kan stängas av i Inställningar → AI-assistent, med alternativet Fråga innan ett helt dokument skickas till AI-motorn; med det av skickas hela dokumentet utan att fråga.

Vad assistenten vet om ditt dokument¶

Agenten läser filer från disken. Lämnad åt sig själv skulle den därför besvara frågor om en fil du redigerat men inte sparat utifrån den gamla texten, och den skulle inte se en namnlös buffert alls. En fri fråga talar därför om för den vad du faktiskt har öppet:

Sparad utan osparade ändringar — assistenten namnger helt enkelt filen och låter agenten läsa den. Inget lämnar redigeraren, så inget frågas.
Osparade ändringar, eller ett dokument som aldrig sparats — den aktuella texten skickas tillsammans med din fråga. Små dokument reser i själva frågan; större skrivs till en tillfällig kopia som agenten pekas mot. Kopian tas bort så snart utbytet slutar.
Med en mapp öppen — varje annat öppet dokument med osparade ändringar tas med på samma sätt, så att agenten ser projektet som du ser det snarare än som det senast sparades.

Eftersom det skickar ut text frågar redigeraren först — en gång per dokument per redigerarsession, och en gång för hela begäran även när flera dokument är inblandade: Det aktuella, osparade innehållet i dessa dokument skickas till Claude: …. Fortsätta? Att neka överger begäran och behåller det du skrivit.

En markering har fortfarande företräde som det du pekar på: den skickas som Relevant markering vid sidan av dokumentet, inte i stället för det.

I det skrivskyddade standardläget får agenten dessutom veta att den inte kan ändra ditt dokument, och att en ändring bör föreslås genom kommandona .refactor, .fix, .tests och .translate — som visar dig en diff.

Granska och tillämpa ändringar¶

Ändringskommandon skriver aldrig om din text tyst. När agenten är klar öppnas en granskningsdialog med en kryssbar, färglagd ändringsgrupp per ändring — borttagna rader i rött, tillagda rader i grönt:

kryssa ur de ändringar du inte vill ha;
Tillämpa ersätter markeringen (eller hela dokumentet, i fallet utan markering) med bara de godtagna ändringarna;
Kasta lämnar bufferten precis som den var.

Tillämpade ändringar är vanliga ändringar, så Ctrl+Z ångrar dem som allt annat. Din fils radslutsstil (CRLF/LF) bevaras. Om agenten avböjer att göra en ändring visas dess förklaring som ett vanligt chattsvar i stället för en falsk diff.

Om du fortsatte redigera medan agenten arbetade splitsar redigeraren aldrig in en inaktuell ändring över din nyare text. Vad den gör i stället beror på vad den fortfarande kan avgöra med säkerhet:

ditt skrivande flyttade målet men lämnade det intakt → ändringen tillämpas där texten står nu;
kommandot omfattade hela dokumentet och dokumentet har ändrats sedan dess → förslaget jämförs mot din aktuella text och du granskar den diffen, så att svaret inte går till spillo;
originaltexten är borta, eller förekommer nu flera gånger → redigeraren avböjer i stället för att gissa, och säger åt dig att köra kommandot igen.

Diff-färgerna följer ditt färgtema: teman kan ange egna färger för Tillagd text i jämförelsen / Borttagen text i jämförelsen (redigerbara i Inställningar → Syntaxfärgning → Teman), och utan dem väljer redigeraren läsbara standardvärden för ljusa och mörka gränssnitt.

Samtal¶

Fria frågor bildar ett fortlöpande samtal: agenten minns dina tidigare frågor och svar. Det finns ett samtal per öppnad mapp (eller per fil, när ingen mapp är öppen), så att orelaterade projekt inte delar sammanhang. Ändringskommandon (.refactor, .fix, …) körs med avsikt engångsvis och smutsar inte ned chattsammanhanget. Samtal bevaras inte — att starta om redigeraren börjar nya.

Både Claude och Codex fortsätter samtal. Codex namnger varje samtal själv och meddelar namnet när det börjar; senare frågor tar upp samtalet därifrån. Om en körning av Codex slutar utan att något namn meddelats visar chatten [konversationen kunde inte fortsättas — motorn angav inget sessions-id; nästa meddelande startar en ny] — svaret du fick gäller, men din nästa fråga startar ett nytt samtal utan det tidigare sammanhanget.

Ett samtal överlever också det som går fel. Att stoppa ett svar behåller det, så att en fråga du avbröt helt enkelt kan tas upp igen — fråga «fortsätt med den senaste uppgiften» så vet agenten fortfarande vad den höll på med, även om du stoppade den innan den hann säga ett ord. Ett enstaka misslyckande (en hastighetsgräns, en bruten anslutning) kastar inte heller historiken; först ett andra misslyckande i rad startar ett nytt samtal.

Stoppa en körning¶

Medan agenten arbetar visas ett upptagetfält med en knapp Stoppa — klicka på den (eller tryck på Esc var som helst i panelen) för att avbryta. Det som strömmat in så långt stannar i utskriften, körningen märks [Avbruten], och ingen ändring tillämpas. Samtalet behålls, så att din nästa fråga fortsätter det (se Samtal). Att trycka på Enter mitt i en körning köar inget; statusraden påminner dig om att agenten fortfarande arbetar.

Låta agenten ändra filer¶

Som standard är assistenten skrivskyddad: varje körning startar agenten med dess filredigeringsverktyg, skalåtkomst och underagenter avstängda, så att ändringar når dig endast som granskningsbara förslag. För motorer med verifierade behörighetsflaggor är detta en hård spärr som agenten själv upprätthåller, oavsett hur din CLI är konfigurerad:

Claude körs med sina filredigeringsverktyg, sin skalåtkomst och sina underagenter avstängda.
Codex körs i sin skrivskyddade sandlåda (-s read-only). Sandlådan fungerar annorlunda: den stänger inte av skalkommandon utan stänger in dem — Codex får fortfarande köra kommandon för att se sig omkring, men de kan inte skriva något. Tills vidare ber redigeraren dessutom Codex uttryckligen att förbli skrivskyddad.

Skrivskyddat är inte garanterat för varje motor

Den hårda spärren bygger på motorns egna behörighetsflaggor. Gemini har ännu inga verifierade flaggor, så redigeraren kan bara be den — som en instruktion efter bästa förmåga — att förbli skrivskyddad; den kan inte tvinga den. Betrakta skrivskyddet som inte garanterat för Gemini: den kan ändå skriva till disken, och dess beteende styrs i slutändan av din CLI:s egen konfiguration. Håll sådant arbete i en mapp under versionshantering om det spelar roll för dig.

Kryssrutan Tillåt filändringar (bredvid motorlistan, av som standard, kommer ihåg mellan sessioner) väljer in redigering på agentsidan:

agentens filändringar godtas automatiskt och den får ändra filer i den öppna mappen under en körning;
varje skrivning rapporteras i samtalet som [the agent modified a file: …], och öppna dokument plockar upp ändringarna genom redigerarens normala filbevakning;
när körningen slutar listar en enda sammanfattningsrad hela uppsättningen berörda filer med ett antal, till exempel [modified files (3): …];
Claudes skalåtkomst och underagenter förblir spärrade även med alternativet på.

Med Codex växlar alternativet dess sandlåda till -s workspace-write: Codex får då ändra filer, och köra skalkommandon, inom den öppna mappen och den tillfälliga katalogen. Codex rapporterar inte sina ändringar till redigeraren, så chatten listar inte de filer den ändrat och det finns ingen sammanfattningsrad; öppna dokument plockar ändå upp ändringarna genom filbevakningen. Själva skrivningarna utförs av Codex egen sandlåda: svarar Codex att den inte kunde starta sin kommandokörare fungerar den sandlådan inte på din dator — kontrollera dess egen diagnostik (codex doctor), inte redigeraren.

Samma strömbrytare finns också i Inställningar → AI-assistent, som Tillåt AI-motorn att redigera filer. De är en inställning, inte två: att tillämpa den i Inställningar kryssar i eller ur panelens kryssruta direkt, och det du ställer in i panelen är det Inställningar visar nästa gång du öppnar den.

Dokument med osparade ändringar hanteras åt dig. Agenten får inte ändra filen på disken för ett dokument du ändrat men inte sparat — den kopian är inaktuell, och att skriva till den skulle lämna filen och din redigerare oense. Agenten får därför den tillfälliga kopian av din aktuella text att ändra i stället, och när körningen slutar för redigeraren tillbaka resultatet i ditt öppna dokument som en vanlig, ångerbar ändring. Namnlösa dokument fungerar på samma sätt, trots att de inte har någon fil alls. Om du råkade redigera dokumentet själv medan agenten arbetade skriver redigeraren inte över dig: den öppnar den vanliga granskningsdialogen mot din aktuella text så att du avgör ändring för ändring. Att stänga dokumentet under körningen kastar helt enkelt agentens arbete, med en anteckning i samtalet.

Tillåt filändringar kan skriva över eller radera ditt arbete

Med alternativet aktiverat skriver agenten direkt till disken och de skrivningarna godtas automatiskt — det finns ingen granskningsdialog per ändring. Agenten kan skriva över, radera eller förstöra filer i den öppna mappen, och ändringar i filer du inte har öppna visas inte för dig som diffar. Aktivera bara detta för en mapp under versionshantering (Git, SVN, …): checka in eller lägg undan ditt arbete först, och använd sedan versionshanteringens diff för att granska varje ändring och återställa allt oönskat — betrakta versionshanteringen som ditt «ångra» för agentens ändringar. Gemini, vars behörighetsflaggor ännu inte är verifierade, ignorerar det här alternativet helt, så dess ändringar styrs enbart av din CLI:s egen konfiguration.

Byta motor¶

Vid start letar redigeraren efter varje motor den känner till, och rullgardinslistan Motor visar bara de som är installerade på den här datorn. Om motorn du valde senast inte längre finns tar den första installerade automatiskt dess plats. En motor som du installerar medan redigeraren körs visas efter en omstart. Är ingen motor alls installerad visar listan varje motor redigeraren känner till, och panelen förblir gråtonad med ledtråden om att installera och logga in.

Välj en annan agent från rullgardinslistan Motor när som helst (den är avstängd medan en körning pågår). Att byta avbryter identifieringen av den föregående motorn, söker efter den nya i bakgrunden, och startar nya samtal — en chatt som påbörjats med en motor kan inte fortsättas av en annan. Bytet tömmer också utskriften, eftersom det samtalet hörde till den andra motorn; det du hade skrivit i inmatningsraden behålls.

Välja modell¶

Som standard ber redigeraren inte om någon modell, så varje körning använder den din CLI-agent är konfigurerad att använda — för Claude Code är det model i din personliga ~/.claude/settings.json. Det är ofta inte vad du vill ha för redigeraren: det är en global inställning, den kan ändras utan att du märker det, och modellen avgör vad varje begäran kostar.

Statusraden talar om vad som faktiskt användes, så du kan alltid kontrollera. För att fästa en modell för redigeraren själv skriver du den i chatten:

Du skriver	Vad som händer
`.model claude-sonnet-5`	varje senare fråga ber om den modellen
`.model`	rapporterar den fästa modellen och den modell som senast faktiskt användes
`.model default`	släpper fästningen; agentens egen standard gäller igen

.model hanteras av redigeraren — den startar aldrig agenten, så den svarar direkt och kostar inget. En fästning får effekt från din nästa fråga, och statusraden bekräftar den när svaret kommer.

Samma sak kan ställas in för hand, per motor, i OctoEdits inställningsfil:

Nyckel	Värde	Effekt
`ai/model/<engine>`	ett modell-id, t.ex. `claude-sonnet-5`	varje körning använder den modellen
`ai/model/<engine>`	tomt / saknas (standard)	CLI-agentens egen standard

<engine> är motorns id som det visas i rullgardinslistan, med gemener — till exempel ai/model/claude eller ai/model/codex. Panelens nästa begäran tar det i bruk; bekräfta det sedan på statusraden. Gemini, vars modellflagga ännu inte är verifierad, ignorerar inställningen.

Relaterad avancerad inställning

ai/programPath/<engine> gör samma sak för den körbara filen: sätt den till en absolut sökväg när agenten är installerad någonstans där redigerarens PATH-sökning inte kan se den. Båda nycklarna är medvetet nödutgångar som bara finns i filen — ett felaktigt värde misslyckas högljutt i stället för att tyst ignoreras.

När en körning misslyckas¶

Avslutas agenten med ett fel visar chatten [agent exited with code N följt av agentens egna felrader och en avslutande ] — för Codex dess startbanner och dess ERROR: …-rader, till exempel det 401 Unauthorized du får när du inte är inloggad. Det räcker oftast för att se vad som gick fel; att köra agenten en gång från en terminal berättar resten.

Redigerarens logg (mte.log, se Loggning och diagnostik) registrerar varje körning på rader som börjar med AI: — vilka motorer som hittades, programmet och argumenten för varje körning, dess slutkod och agentens sista felrader när en körning misslyckas; att starta redigeraren med --log=debug lägger till resten av agentens diagnostikutdata. Din fråga och svaret visas aldrig i felmeddelandet och skrivs aldrig till loggen: loggen anger bara frågans storlek i byte.

Integritet och kostnad¶

Begäranden skickas av den CLI-agent du valde, med dess eget konto och dess egen nätverksanslutning — redigeraren lägger inte till någon separat telemetri eller några egna slutpunkter. (Codex upprepar hela utbytet i sin diagnostikutdata; redigeraren kastar den kopian och skriver den aldrig till sin logg.) Vad som skickas (din instruktion, din markering eller ditt dokument, och den osparade texten i öppna dokument när en fråga behöver den) och vad det kostar styrs av den agentens prenumeration eller plan. Inget lämnar redigeraren utan samtyckesfrågan som beskrivs ovan, och statusraden namnger den modell varje begäran faktiskt använde.

Vad som levereras i dag

Kommandon arbetar på den aktuella markeringen (eller hela dokumentet, med samtycke) och ersätter den när de godtas. Det finns två nivåer av befogenhet: det skrivskyddade flödet med enbart förslag ovan, eller det uttryckliga valet Tillåt filändringar. Det finns ingen separat granskning i redigeraren av agentens egna skrivningar till disken — med Tillåt filändringar på förlitar du dig i stället på din versionshantering; det enda undantaget är ett dokument som är öppet med osparade ändringar, vars ändringar kommer tillbaka genom redigeraren.