Git stash: spara ändringar före ett AI-försök

1. Inventera fyra slags filer

Du har en halvfärdig ändring och vill prova en annan lösning med en AI-agent. Git stash passar för en kort paus i samma arbetskatalog. Guiden omfattar ett vanligt lokalt repository med minst en commit, utan submoduler. För en separat katalog och gren finns guiden om Git worktree. Här tränar du i stället på undanläggning och återläggning. Stash ersätter varken en separat säkerhetskopia eller en begränsad körmiljö för kod.

Börja med provet nedan innan du använder flödet i ditt projekt. Det skapar en ny katalog under din temporärmapp och gör endast lokala commits. Kör PowerShell-blocken i ordning i samma terminal. Följ också exitkoderna: om ett Git-kommando misslyckas ska du stanna och läsa felet, inte fortsätta till nästa block.

$provKatalog = Join-Path ([System.IO.Path]::GetTempPath()) ('stash-prov-' + [guid]::NewGuid())
New-Item -ItemType Directory -Path $provKatalog | Out-Null
Set-Location $provKatalog
git --version
git init -b main
git config user.name 'Stashprov'
git config user.email 'stashprov@example.invalid'
git config core.autocrlf false
$utf8 = New-Object System.Text.UTF8Encoding($false)
[System.IO.File]::WriteAllText("$provKatalog/.gitignore", "ignored.txt\n".Replace('\n', "`n"), $utf8)
[System.IO.File]::WriteAllText("$provKatalog/staged.txt", "base`n", $utf8)
[System.IO.File]::WriteAllText("$provKatalog/work.txt", "base`n", $utf8)
git add -- .gitignore staged.txt work.txt
git commit -m 'Bas för stashprov'
if ($LASTEXITCODE -ne 0) { throw 'Basen kunde inte sparas' }
[System.IO.File]::WriteAllText("$provKatalog/staged.txt", "staged`n", $utf8)
git add -- staged.txt
[System.IO.File]::WriteAllText("$provKatalog/staged.txt", "staged`nworking`n", $utf8)
[System.IO.File]::WriteAllText("$provKatalog/work.txt", "working`n", $utf8)
[System.IO.File]::WriteAllText("$provKatalog/note.txt", "note`n", $utf8)
[System.IO.File]::WriteAllText("$provKatalog/ignored.txt", "local`n", $utf8)
git status --short --untracked-files=all --ignored
git diff
git diff --cached

Facit är MM framför staged.txt, ett M i andra kolumnen framför work.txt, ?? framför note.txt och !! framför ignored.txt. staged.txt har först lagts i index och sedan ändrats igen. Du har alltså både staged och unstaged arbete i samma fil. Git status-dokumentationen beskriver de två statuskolumnerna och markeringarna för ospårat och ignorerat material.

Git diff-dokumentationen skiljer mellan arbetskatalogens ändringar mot index och indexets ändringar mot HEAD. Den vanliga diffen ska visa raden working i staged.txt samt ändringen i work.txt. Den cachade diffen ska visa bytet från base till staged. Öppna även note.txt och ignored.txt; dessa ingår inte i de två diffarna. Skriv upp statusen och filinnehållen som ditt jämförelseunderlag.

2. Spara en namngiven stash med vald omfattning

I provet vill du lägga undan samtliga spårade ändringar och note.txt. Därför används -u. Enligt Git stash-dokumentationen omfattar flaggan ospårade filer; ignorerade filer kräver en annan omfattning. ignored.txt ska här ligga kvar. Kontrollera särskilt vilka lokala filer som lämnas i katalogen innan agenten får arbeta där.

$basGren = git branch --show-current
$basCommit = git rev-parse HEAD
git stash push -u -m 'Eget arbete före AI-prov'
if ($LASTEXITCODE -ne 0) { throw 'Stash misslyckades' }
$stashId = git rev-parse 'stash@{0}'
git status --short --untracked-files=all --ignored

Facit är enbart !! ignored.txt i detta prov. staged.txt och work.txt ska innehålla base igen; note.txt ska ha lagts undan. Notera grennamn, basens commit-id och stashens commit-id utanför projektkatalogen. Gör samma inventering i ditt verkliga projekt innan du väljer omfattning. Om du saknar ändringar kan kommandot rapportera att inget sparades: då får en äldre stash inte misstas för dagens arbete.

Utan -u sparas normalt de spårade ändringarna. Du kan också begränsa push med filnamn efter --, exempelvis git stash push -u -m 'Formulär före AI-prov' -- src/formular.js note.txt. Dokumentationen anger att filer utanför en sådan pathspec lämnas kvar. Den varianten kräver därför en ny statuskontroll; den gör inte automatiskt hela projektet redo för försöket. Använd inte --keep-index i detta flöde, eftersom staged arbete då lämnas kvar.

3. Inspektera innehållet och behåll identifieraren

git stash list
git stash show --include-untracked --stat $stashId
git stash show --include-untracked -p $stashId

Granska både filöversikten och patchen. Facit i provet är att staged.txt, work.txt och note.txt finns med, medan ignored.txt saknas. Patchen visar det sparade arbetsinnehållet; din tidigare cachade diff behövs fortfarande som facit för vilka ändringar som var staged. Kontrollera att meddelandet motsvarar ditt försök innan du går vidare.

stash@{0} betecknar den senaste posten. Listpositionen kan ändras när fler stashes skapas, så använd det noterade commit-id:t för detta försök. Git-dokumentationen tillåter ett stashliknande commit-objekt som argument till apply. Ett nedskrivet id hjälper dig välja rätt post men är ingen kopia av repositoryts data. Låt posten ligga kvar i stashlistan.

4. Hantera AI-försöket på en avgränsad gren

Skapa en ny gren från den noterade basen och låt försöket ha en tydlig uppgift. I träningsrepot ersätter en enda textfil AI-arbetet; ingen agent körs. Du sparar resultatet på försöksgrenen för att sedan kunna återvända utan att blanda ihop det med ditt eget arbete. Använd ett nytt grennamn om namnet redan finns.

git switch -c ai/stash-prov $basCommit
if ($LASTEXITCODE -ne 0) { throw 'Grenen kunde inte skapas' }
[System.IO.File]::WriteAllText("$provKatalog/ai.txt", "AI-resultat`n", $utf8)
git diff
git status --short
git add -- ai.txt
git diff --cached
git commit -m 'Spara försöket på egen gren'
if ($LASTEXITCODE -ne 0) { throw 'Försöket kunde inte sparas' }
git status --short --untracked-files=all --ignored

Facit är en commit med ai.txt på ai/stash-prov och endast den väntade ignorerade filen i statusen. I ett verkligt projekt ska du först granska samtliga ändrade och nya filer och köra uppgiftens relevanta prov. Guiden om kodgranskning hjälper dig kontrollera resultatet innan du beslutar om integration. En försökscommit kan behållas för granskning utan att den integreras nu.

Om försöket fortfarande har ocommittade ändringar ska du stoppa här och hantera dem separat. Välj medvetet vilka filer som ska sparas; använd inte en automatisk återställning eller rensning som genväg. Gör inte heller återläggningen ovanpå ett pågående agentjobb. Avsluta agentens arbete och kontrollera terminalens katalog och gren.

5. Återgå till vald bas och använd apply --index

Det här provet återgår till den ursprungliga grenen och samma commit. Kontrollera båda. Om din verkliga bas har flyttats behöver du granska vad som ändrats innan du bestämmer var arbetet ska återläggas. En annan bas kan ge konflikter; fortsätt inte bara för att statusen ser ren ut.

git switch $basGren
if ($LASTEXITCODE -ne 0) { throw 'Grenbytet stoppade' }
git branch --show-current
git rev-parse HEAD
git status --short --untracked-files=all --ignored
if ((git rev-parse HEAD) -ne $basCommit) { throw 'Basen har ändrats; granska först' }
git stash apply --index $stashId
if ($LASTEXITCODE -ne 0) { throw 'Återläggningen stoppade; undersök läget' }

apply behåller posten i stashlistan. --index försöker dessutom återställa indexets ändringar och kan misslyckas vid konflikt, enligt Git stash-dokumentationen. Därför har provet ett uttryckligt stopp vid felkod. Kör inte apply en gång till i ett delvis återlagt läge. Läs status, diff och felmeddelande och behåll stashen medan du utreder hur arbetet ska återställas.

6. Kontrollera arbetskatalog, index och kvarvarande stash

git status --short --untracked-files=all --ignored
git diff
git diff --cached
git diff --check
git diff --cached --check
Get-Content staged.txt, work.txt, note.txt, ignored.txt
git stash list --format='%H %gs'

Facit är samma fyra statusrader som före undanläggningen. Den vanliga och den cachade diffen ska motsvara dina ursprungliga diffar. staged.txt innehåller staged följt av working, work.txt innehåller working, note.txt innehåller note och ignored.txt innehåller local. Stashlistan ska fortfarande innehålla det noterade id:t. Kontrollera alla dessa delar innan du godkänner återläggningen; enbart filinnehållet visar inte om indexet blev rätt.

--check hjälper dig hitta konfliktmarkörer och whitespacefel i diffen enligt Git diff-dokumentationen. Det ersätter inte projektets funktionella prov. Kör relevanta tester igen och läs deras resultat. Om status visar omergade filer, om indexet avviker eller om en ospårad fil saknas är återläggningen ännu inte godkänd. Låt försöksgrenen och stashen ligga kvar medan du undersöker orsaken.