do not show branch graph when in filtering mode

make integration test pass
allow sandbox mode with integration tests
2022-01-17 19:24:10 +11:00 · 2022-01-17 19:14:59 +11:00 · 2022-01-17 19:14:59 +11:00 · 2022-01-17 19:14:59 +11:00 · 2022-01-17 19:14:59 +11:00 · 2022-01-17 19:14:59 +11:00
601 changed files with 9125 additions and 4356 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -63,3 +63,43 @@ jobs:
      - name: Build darwin binary
        run: |
          GOOS=darwin go build
+  check-cheatsheet:
+    runs-on: ubuntu-latest
+    env:
+      GOFLAGS: -mod=vendor
+      GOARCH: amd64
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Setup Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.16.x
+      - name: Cache build
+        uses: actions/cache@v1
+        with:
+          path: ~/.cache/go-build
+          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}-build
+          restore-keys: |
+            ${{runner.os}}-go-
+      - name: Check Cheatsheet
+        run: |
+          go run scripts/cheatsheet/main.go check
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: latest
+      - name: Format code
+        run: |
+          if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
+           find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
+           exit 1
+          fi
+      - name: errors
+        run: golangci-lint run
+        if: ${{ failure() }}
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -1,20 +0,0 @@
-name: Lint
-
-on: pull_request
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: latest
-      - name: Format code
-        run: |
-          if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
-           find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
-           exit 1
-          fi
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -46,7 +46,7 @@ Sometimes you will need to make a change in the gocui fork (https://github.com/j
 4. After that PR is merged, make a PR in lazygit bumping the gocui version. You can bump the version by running the following at the lazygit repo root:

 ```sh
-./bump_gocui.sh
+./scripts/bump_gocui.sh
 ```

 5. Raise a PR in lazygit with those changes
--- a/docs/Integration_Tests.md
+++ b/docs/Integration_Tests.md
@@ -33,17 +33,32 @@ git commit -am "myfile1"

 ## Running tests

+### From a TUI
+
+You can run/record/sandbox tests via a TUI with the following command:
+
+```
+go run test/lazyintegration/main.go
+```
+
+This TUI makes much of the following documentation redundant, but feel free to read through anyway!
+
+### From command line
+
 To run all tests - assuming you're at the project root:
+
 ```
 go test ./pkg/gui/
 ```

 To run them in parallel
+
 ```
 PARALLEL=true go test ./pkg/gui
 ```

 To run a single test
+
 ```
 go test ./pkg/gui -run /<test name>
 # For example, to run the `tags` test:
@@ -51,29 +66,35 @@ go test ./pkg/gui -run /tags
 ```

 To run a test at a certain speed
+
 ```
 SPEED=2 go test ./pkg/gui -run /<test name>
 ```

 To update a snapshot
+
 ```
-UPDATE_SNAPSHOTS=true go test ./pkg/gui -run /<test name>
+MODE=updateSnapshot go test ./pkg/gui -run /<test name>
 ```

 ## Creating a new test

 To create a new test:
-1) Copy and paste an existing test directory and rename the new directory to whatever you want the test name to be. Update the test.json file's description to describe your test.
-2) Update the `setup.sh` any way you like
-3) If you want to have a config folder for just that test, create a `config` directory to contain a `config.yml` and optionally a `state.yml` file. Otherwise, the `test/default_test_config` directory will be used.
-4) From the lazygit root directory, run:
+
+1. Copy and paste an existing test directory and rename the new directory to whatever you want the test name to be. Update the test.json file's description to describe your test.
+2. Update the `setup.sh` any way you like
+3. If you want to have a config folder for just that test, create a `config` directory to contain a `config.yml` and optionally a `state.yml` file. Otherwise, the `test/default_test_config` directory will be used.
+4. From the lazygit root directory, run:
+
 ```
-RECORD_EVENTS=true go test ./pkg/gui -run /<test name>
+MODE=record go test ./pkg/gui -run /<test name>
 ```
-5) Feel free to re-attempt recording as many times as you like. In the absence of a proper testing framework, the more deliberate your keypresses, the better!
-6) Once satisfied with the recording, stage all the newly created files: `test.json`, `setup.sh`, `recording.json` and the `expected` directory that contains a copy of the repo you created.
+
+5. Feel free to re-attempt recording as many times as you like. In the absence of a proper testing framework, the more deliberate your keypresses, the better!
+6. Once satisfied with the recording, stage all the newly created files: `test.json`, `setup.sh`, `recording.json` and the `expected` directory that contains a copy of the repo you created.

 The resulting directory will look like:
+
 ```
 actual/ (the resulting repo after running the test, ignored by git)
 expected/ (the 'snapshot' repo)
@@ -85,6 +106,14 @@ recording.json

 Feel free to create a hierarchy of directories in the `test/integration` directory to group tests by feature.

+## Sandboxing
+
+The integration tests serve a secondary purpose of providing a setup for easy sandboxing. If you want to run a test in sandbox mode (meaning the session won't be recorded and we won't create/update snapshots), go:
+
+```
+MODE=sandbox go test ./pkg/gui -run /<test name>
+```
+
 ## Feedback

 If you think this process can be improved, let me know! It shouldn't be too hard to change things.
--- a/docs/keybindings/Keybindings_en.md
+++ b/docs/keybindings/Keybindings_en.md
@@ -1,3 +1,5 @@
+# This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root.
+
 # Lazygit Keybindings

 ## Global Keybindings
@@ -21,6 +23,8 @@
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
  <kbd>@</kbd>: open command log menu
+  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
+  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>

 ## List Panel Navigation
@@ -119,6 +123,7 @@
 ## Commits Panel (Commits)

 <pre>
+  <kbd>ctrl+l</kbd>: open log menu
  <kbd>s</kbd>: squash down
  <kbd>r</kbd>: reword commit
  <kbd>R</kbd>: reword commit with editor
@@ -143,6 +148,7 @@
  <kbd>T</kbd>: tag commit
  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
  <kbd>ctrl+y</kbd>: copy commit message to clipboard
+  <kbd>o</kbd>: open commit in browser
 </pre>

 ## Commits Panel (Reflog Tab)
@@ -163,6 +169,12 @@
  <kbd>@</kbd>: open command log menu
 </pre>

+## Files Panel
+
+<pre>
+  <kbd>ctrl+b</kbd>: Filter commit files
+</pre>
+
 ## Files Panel (Files)

 <pre>
@@ -205,6 +217,8 @@
 ## Main Panel (Merging)

 <pre>
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
  <kbd>esc</kbd>: return to files panel
  <kbd>M</kbd>: open external merge tool (git mergetool)
  <kbd>space</kbd>: pick hunk
@@ -232,10 +246,13 @@
  <kbd>▼</kbd>: select next line
  <kbd>◄</kbd>: select previous hunk
  <kbd>►</kbd>: select next hunk
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>space</kbd>: add/remove line(s) to patch
  <kbd>v</kbd>: toggle drag select
  <kbd>V</kbd>: toggle drag select
  <kbd>a</kbd>: toggle select hunk
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
 </pre>

 ## Main Panel (Staging)
@@ -250,11 +267,14 @@
  <kbd>▼</kbd>: select next line
  <kbd>◄</kbd>: select previous hunk
  <kbd>►</kbd>: select next hunk
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>e</kbd>: edit file
  <kbd>o</kbd>: open file
  <kbd>v</kbd>: toggle drag select
  <kbd>V</kbd>: toggle drag select
  <kbd>a</kbd>: toggle select hunk
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
  <kbd>c</kbd>: commit changes
  <kbd>w</kbd>: commit changes without pre-commit hook
  <kbd>C</kbd>: commit changes using git editor
--- a/docs/keybindings/Keybindings_nl.md
+++ b/docs/keybindings/Keybindings_nl.md
@@ -1,3 +1,5 @@
+# This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root.
+
 # Lazygit Sneltoetsen

 ## Globale Sneltoetsen
@@ -21,6 +23,8 @@
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
  <kbd>@</kbd>: open command log menu
+  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
+  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>

 ## Lijstpaneel Navigatie
@@ -119,6 +123,7 @@
 ## Commits Paneel (Commits)

 <pre>
+  <kbd>ctrl+l</kbd>: open log menu
  <kbd>s</kbd>: squash beneden
  <kbd>r</kbd>: hernoem commit
  <kbd>R</kbd>: hernoem commit met editor
@@ -143,6 +148,7 @@
  <kbd>T</kbd>: tag commit
  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
  <kbd>ctrl+y</kbd>: kopieer commit bericht naar klembord
+  <kbd>o</kbd>: open commit in browser
 </pre>

 ## Commits Paneel (Reflog Tabblad)
@@ -163,6 +169,12 @@
  <kbd>@</kbd>: open command log menu
 </pre>

+## Bestanden Paneel
+
+<pre>
+  <kbd>ctrl+b</kbd>: Commit dossiers filteren
+</pre>
+
 ## Bestanden Paneel (Bestanden)

 <pre>
@@ -205,6 +217,8 @@
 ## Hoofd Paneel (Mergen)

 <pre>
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
  <kbd>esc</kbd>: ga terug naar het bestanden paneel
  <kbd>M</kbd>: open external merge tool (git mergetool)
  <kbd>space</kbd>: kies hunk
@@ -232,10 +246,13 @@
  <kbd>▼</kbd>: selecteer de volgende lijn
  <kbd>◄</kbd>: selecteer de vorige hunk
  <kbd>►</kbd>: selecteer de volgende hunk
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>space</kbd>: voeg toe/verwijder lijn(en) in patch
  <kbd>v</kbd>: toggle drag selecteer
  <kbd>V</kbd>: toggle drag selecteer
  <kbd>a</kbd>: toggle selecteer hunk
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
 </pre>

 ## Hoofd Paneel (Staging)
@@ -250,11 +267,14 @@
  <kbd>▼</kbd>: selecteer de volgende lijn
  <kbd>◄</kbd>: selecteer de vorige hunk
  <kbd>►</kbd>: selecteer de volgende hunk
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>e</kbd>: verander bestand
  <kbd>o</kbd>: open bestand
  <kbd>v</kbd>: toggle drag selecteer
  <kbd>V</kbd>: toggle drag selecteer
  <kbd>a</kbd>: toggle selecteer hunk
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
  <kbd>c</kbd>: Commit veranderingen
  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
  <kbd>C</kbd>: commit veranderingen met de git editor
--- a/docs/keybindings/Keybindings_pl.md
+++ b/docs/keybindings/Keybindings_pl.md
@@ -1,3 +1,5 @@
+# This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root.
+
 # Lazygit Keybindings

 ## Globalne
@@ -6,7 +8,7 @@
  <kbd>ctrl+r</kbd>: switch to a recent repo (<c-r>)
  <kbd>pgup</kbd>: scroll up main panel (fn+up)
  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
-  <kbd>m</kbd>: view merge/rebase options
+  <kbd>m</kbd>: widok scalenia/opcje zmiany bazy
  <kbd>ctrl+p</kbd>: view custom patch options
  <kbd>P</kbd>: push
  <kbd>p</kbd>: pull
@@ -16,11 +18,13 @@
  <kbd>ctrl+z</kbd>: redo (via reflog) (experimental)
  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: execute custom command
+  <kbd>:</kbd>: wykonaj własną komendę
  <kbd>ctrl+s</kbd>: view filter-by-path options
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
  <kbd>@</kbd>: open command log menu
+  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
+  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>

 ## List Panel Navigation
@@ -39,18 +43,18 @@

 <pre>
  <kbd>space</kbd>: przełącz
-  <kbd>o</kbd>: utwórz żądanie wyciągnięcia
+  <kbd>o</kbd>: utwórz żądanie pobrania
  <kbd>O</kbd>: utwórz opcje żądania ściągnięcia
-  <kbd>ctrl+y</kbd>: skopiuj adres URL żądania ściągnięcia do schowka
+  <kbd>ctrl+y</kbd>: skopiuj adres URL żądania pobrania do schowka
  <kbd>c</kbd>: przełącz używając nazwy
  <kbd>F</kbd>: wymuś przełączenie
  <kbd>n</kbd>: nowa gałąź
  <kbd>d</kbd>: usuń gałąź
-  <kbd>r</kbd>: rebase branch
+  <kbd>r</kbd>: zmiana bazy gałęzi
  <kbd>M</kbd>: scal do obecnej gałęzi
  <kbd>i</kbd>: show git-flow options
  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: view reset options
+  <kbd>g</kbd>: wyświetl opcje resetu
  <kbd>R</kbd>: rename branch
  <kbd>ctrl+o</kbd>: copy branch name to clipboard
  <kbd>enter</kbd>: view commits
@@ -59,14 +63,14 @@
 ## Gałęzie Panel (Remote Branches (in Remotes tab))

 <pre>
-  <kbd>esc</kbd>: return to remotes list
-  <kbd>g</kbd>: view reset options
+  <kbd>esc</kbd>: wróć do listy repozytoriów zdalnych
+  <kbd>g</kbd>: wyświetl opcje resetu
  <kbd>enter</kbd>: view commits
  <kbd>space</kbd>: przełącz
  <kbd>n</kbd>: nowa gałąź
  <kbd>M</kbd>: scal do obecnej gałęzi
  <kbd>d</kbd>: usuń gałąź
-  <kbd>r</kbd>: rebase branch
+  <kbd>r</kbd>: zmiana bazy gałęzi
  <kbd>u</kbd>: set as upstream of checked-out branch
 </pre>

@@ -82,12 +86,12 @@
 ## Gałęzie Panel (Sub-commits)

 <pre>
-  <kbd>enter</kbd>: view commit's files
+  <kbd>enter</kbd>: przeglądaj pliki commita
  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
+  <kbd>g</kbd>: wyświetl opcje resetu
  <kbd>n</kbd>: nowa gałąź
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
+  <kbd>c</kbd>: kopiuj commit (przebieranie)
+  <kbd>C</kbd>: kopiuj zakres commitów (przebieranie)
  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
 </pre>
@@ -99,16 +103,16 @@
  <kbd>d</kbd>: delete tag
  <kbd>P</kbd>: push tag
  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: view reset options
+  <kbd>g</kbd>: wyświetl opcje resetu
  <kbd>enter</kbd>: view commits
 </pre>

-## Commit files Panel
+## Pliki commita Panel

 <pre>
  <kbd>ctrl+o</kbd>: copy the committed file name to the clipboard
-  <kbd>c</kbd>: checkout file
-  <kbd>d</kbd>: discard this commit's changes to this file
+  <kbd>c</kbd>: plik wybierania
+  <kbd>d</kbd>: porzuć zmiany commita dla tego pliku
  <kbd>o</kbd>: otwórz plik
  <kbd>e</kbd>: edytuj plik
  <kbd>space</kbd>: toggle file included in patch
@@ -119,40 +123,42 @@
 ## Commity Panel (Commity)

 <pre>
-  <kbd>s</kbd>: ściśnij w dół
-  <kbd>r</kbd>: przemianuj commit
-  <kbd>R</kbd>: przemianuj commit w edytorze
+  <kbd>ctrl+l</kbd>: open log menu
+  <kbd>s</kbd>: ściśnij
+  <kbd>r</kbd>: zmień nazwę commita
+  <kbd>R</kbd>: zmień nazwę commita w edytorze
  <kbd>g</kbd>: zresetuj do tego commita
  <kbd>f</kbd>: napraw commit
-  <kbd>F</kbd>: create fixup commit for this commit
-  <kbd>S</kbd>: squash all 'fixup!' commits above selected commits (autosquash)
-  <kbd>d</kbd>: delete commit
-  <kbd>ctrl+j</kbd>: move commit down one
-  <kbd>ctrl+k</kbd>: move commit up one
-  <kbd>e</kbd>: edit commit
-  <kbd>A</kbd>: amend commit with staged changes
-  <kbd>p</kbd>: pick commit (when mid-rebase)
-  <kbd>t</kbd>: revert commit
-  <kbd>c</kbd>: copy commit (cherry-pick)
+  <kbd>F</kbd>: utwórz commit naprawczy dla tego commita
+  <kbd>S</kbd>: spłaszcz wszystkie commity naprawcze powyżej zaznaczonych commitów (autosquash)
+  <kbd>d</kbd>: usuń commit
+  <kbd>ctrl+j</kbd>: przenieś commit 1 w dół
+  <kbd>ctrl+k</kbd>: przenieś commit 1 w górę
+  <kbd>e</kbd>: edytuj commit
+  <kbd>A</kbd>: popraw commit zmianami z poczekalni
+  <kbd>p</kbd>: wybierz commit (podczas zmiany bazy)
+  <kbd>t</kbd>: odwróć commit
+  <kbd>c</kbd>: kopiuj commit (przebieranie)
  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>v</kbd>: paste commits (cherry-pick)
-  <kbd>enter</kbd>: view commit's files
+  <kbd>C</kbd>: kopiuj zakres commitów (przebieranie)
+  <kbd>v</kbd>: wklej commity (przebieranie)
+  <kbd>enter</kbd>: przeglądaj pliki commita
  <kbd>space</kbd>: checkout commit
  <kbd>n</kbd>: create new branch off of commit
  <kbd>T</kbd>: tag commit
  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
  <kbd>ctrl+y</kbd>: copy commit message to clipboard
+  <kbd>o</kbd>: open commit in browser
 </pre>

 ## Commity Panel (Reflog Tab)

 <pre>
-  <kbd>enter</kbd>: view commit's files
+  <kbd>enter</kbd>: przeglądaj pliki commita
  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
+  <kbd>g</kbd>: wyświetl opcje resetu
+  <kbd>c</kbd>: kopiuj commit (przebieranie)
+  <kbd>C</kbd>: kopiuj zakres commitów (przebieranie)
  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
 </pre>
@@ -163,25 +169,31 @@
  <kbd>@</kbd>: open command log menu
 </pre>

+## Pliki Panel
+
+<pre>
+  <kbd>ctrl+b</kbd>: Filtrowanie commitów
+</pre>
+
 ## Pliki Panel (Pliki)

 <pre>
-  <kbd>c</kbd>: commituj zmiany
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>A</kbd>: zmień ostatnie zatwierdzenie
-  <kbd>C</kbd>: commituj zmiany używając edytora z gita
-  <kbd>space</kbd>: przełącz zatwierdzenie
-  <kbd>d</kbd>: view 'discard changes' options
+  <kbd>c</kbd>: Zatwierdź zmiany
+  <kbd>w</kbd>: zatwierdź zmiany bez skryptu pre-commit
+  <kbd>A</kbd>: Zmień ostatni commit
+  <kbd>C</kbd>: Zatwierdź zmiany używając edytora
+  <kbd>space</kbd>: przełącz stan poczekalni
+  <kbd>d</kbd>: pokaż opcje porzucania zmian
  <kbd>e</kbd>: edytuj plik
  <kbd>o</kbd>: otwórz plik
  <kbd>i</kbd>: dodaj do .gitignore
  <kbd>r</kbd>: odśwież pliki
-  <kbd>s</kbd>: przechowaj pliki
-  <kbd>S</kbd>: view stash options
-  <kbd>a</kbd>: przełącz wszystkie zatwierdzenia
-  <kbd>D</kbd>: view reset options
+  <kbd>s</kbd>: przechowaj zmiany
+  <kbd>S</kbd>: wyświetl opcje schowka
+  <kbd>a</kbd>: przełącz stan poczekalni wszystkich
+  <kbd>D</kbd>: wyświetl opcje resetu
  <kbd>enter</kbd>: zatwierdź pojedyncze linie
-  <kbd>f</kbd>: fetch
+  <kbd>f</kbd>: pobierz
  <kbd>ctrl+o</kbd>: copy the file name to the clipboard
  <kbd>g</kbd>: view upstream reset options
  <kbd>`</kbd>: toggle file tree view
@@ -202,43 +214,48 @@
  <kbd>b</kbd>: view bulk submodule options
 </pre>

-## Main Panel (Merging)
+## Główne Panel (Scalanie)

 <pre>
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
  <kbd>esc</kbd>: wróć do panelu plików
  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>space</kbd>: pick hunk
-  <kbd>b</kbd>: pick all hunks
-  <kbd>◄</kbd>: select previous conflict
-  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select previous hunk
-  <kbd>▼</kbd>: select next hunk
+  <kbd>space</kbd>: wybierz kawałek
+  <kbd>b</kbd>: wybierz wszystkie kawałki
+  <kbd>◄</kbd>: poprzedni konflikt
+  <kbd>►</kbd>: następny konflikt
+  <kbd>▲</kbd>: wybierz poprzedni kawałek
+  <kbd>▼</kbd>: wybierz następny kawałek
  <kbd>z</kbd>: cofnij
 </pre>

-## Main Panel (Normal)
+## Główne Panel (Zwykłe)

 <pre>
-  <kbd>Ő</kbd>: scroll down (fn+up)
-  <kbd>ő</kbd>: scroll up (fn+down)
+  <kbd>Ő</kbd>: przewiń w dół (fn+up)
+  <kbd>ő</kbd>: przewiń w górę (fn+down)
 </pre>

-## Main Panel (Patch Building)
+## Główne Panel (Patch Building)

 <pre>
-  <kbd>esc</kbd>: exit line-by-line mode
+  <kbd>esc</kbd>: wyście z trybu "linia po linii"
  <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
+  <kbd>▲</kbd>: poprzednia linia
+  <kbd>▼</kbd>: następna linia
+  <kbd>◄</kbd>: poprzedni kawałek
+  <kbd>►</kbd>: następny kawałek
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>space</kbd>: add/remove line(s) to patch
  <kbd>v</kbd>: toggle drag select
  <kbd>V</kbd>: toggle drag select
  <kbd>a</kbd>: toggle select hunk
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
 </pre>

-## Main Panel (Zatwierdzanie)
+## Główne Panel (Poczekalnia)

 <pre>
  <kbd>esc</kbd>: wróć do panelu plików
@@ -246,18 +263,21 @@
  <kbd>d</kbd>: delete change (git reset)
  <kbd>tab</kbd>: switch to other panel
  <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
+  <kbd>▲</kbd>: poprzednia linia
+  <kbd>▼</kbd>: następna linia
+  <kbd>◄</kbd>: poprzedni kawałek
+  <kbd>►</kbd>: następny kawałek
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
  <kbd>e</kbd>: edytuj plik
  <kbd>o</kbd>: otwórz plik
  <kbd>v</kbd>: toggle drag select
  <kbd>V</kbd>: toggle drag select
  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: commituj zmiany
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>C</kbd>: commituj zmiany używając edytora z gita
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
+  <kbd>c</kbd>: Zatwierdź zmiany
+  <kbd>w</kbd>: zatwierdź zmiany bez skryptu pre-commit
+  <kbd>C</kbd>: Zatwierdź zmiany używając edytora
 </pre>

 ## Menu Panel
@@ -279,9 +299,9 @@
 ## Status Panel

 <pre>
-  <kbd>e</kbd>: edytuj plik konfiguracyjny
-  <kbd>o</kbd>: otwórz plik konfiguracyjny
+  <kbd>e</kbd>: edytuj konfigurację
+  <kbd>o</kbd>: otwórz konfigurację
  <kbd>u</kbd>: sprawdź aktualizacje
  <kbd>enter</kbd>: switch to a recent repo
-  <kbd>a</kbd>: pokazywać wszystkie logi branżowe
+  <kbd>a</kbd>: pokaż wszystkie logi gałęzi
 </pre>
--- a/docs/keybindings/Keybindings_zh.md
+++ b/docs/keybindings/Keybindings_zh.md
@@ -0,0 +1,307 @@
+# This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root.
+
+# Lazygit 按键绑定
+
+## 全局键绑定
+
+<pre>
+  <kbd>ctrl+r</kbd>: 切换到最近的仓库 (<c-r>)
+  <kbd>pgup</kbd>: 向上滚动主面板 (fn+up)
+  <kbd>pgdown</kbd>: 向下滚动主面板 (fn+down)
+  <kbd>m</kbd>: 查看 合并/变基 选项
+  <kbd>ctrl+p</kbd>: 查看自定义补丁选项
+  <kbd>P</kbd>: 推送
+  <kbd>p</kbd>: 拉取
+  <kbd>R</kbd>: 刷新
+  <kbd>x</kbd>: 打开菜单
+  <kbd>z</kbd>: （通过 reflog）撤销「实验功能」
+  <kbd>ctrl+z</kbd>: （通过 reflog）重做「实验功能」
+  <kbd>+</kbd>: 下一屏模式（正常/半屏/全屏）
+  <kbd>_</kbd>: 上一屏模式
+  <kbd>:</kbd>: 执行自定义命令
+  <kbd>ctrl+s</kbd>: 查看按路径过滤选项
+  <kbd>W</kbd>: 打开 diff 菜单
+  <kbd>ctrl+e</kbd>: 打开 diff 菜单
+  <kbd>@</kbd>: 打开命令日志菜单
+  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
+  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
+</pre>
+
+## 列表面板导航
+
+<pre>
+  <kbd>.</kbd>: 下一页
+  <kbd>,</kbd>: 上一页
+  <kbd><</kbd>: 滚动到顶部
+  <kbd>></kbd>: 滚动到底部
+  <kbd>/</kbd>: 开始搜索
+  <kbd>]</kbd>: 下一个标签
+  <kbd>[</kbd>: 上一个标签
+</pre>
+
+## 分支 面板 (分支标签)
+
+<pre>
+  <kbd>space</kbd>: 检出
+  <kbd>o</kbd>: 创建抓取请求
+  <kbd>O</kbd>: 创建抓取请求选项
+  <kbd>ctrl+y</kbd>: 将抓取请求 URL 复制到剪贴板
+  <kbd>c</kbd>: 按名称检出
+  <kbd>F</kbd>: 强制检出
+  <kbd>n</kbd>: 新分支
+  <kbd>d</kbd>: 删除分支
+  <kbd>r</kbd>: 将已检出的分支变基到该分支
+  <kbd>M</kbd>: 合并到当前检出的分支
+  <kbd>i</kbd>: 显示 git-flow 选项
+  <kbd>f</kbd>: 从上游快进此分支
+  <kbd>g</kbd>: 查看重置选项
+  <kbd>R</kbd>: 重命名分支
+  <kbd>ctrl+o</kbd>: 将分支名称复制到剪贴板
+  <kbd>enter</kbd>: 查看提交
+</pre>
+
+## 分支 面板 (远程分支（在远程页面中）)
+
+<pre>
+  <kbd>esc</kbd>: 返回远程仓库列表
+  <kbd>g</kbd>: 查看重置选项
+  <kbd>enter</kbd>: 查看提交
+  <kbd>space</kbd>: 检出
+  <kbd>n</kbd>: 新分支
+  <kbd>M</kbd>: 合并到当前检出的分支
+  <kbd>d</kbd>: 删除分支
+  <kbd>r</kbd>: 将已检出的分支变基到该分支
+  <kbd>u</kbd>: 设置为检出分支的上游
+</pre>
+
+## 分支 面板 (远程页面)
+
+<pre>
+  <kbd>f</kbd>: 抓取远程仓库
+  <kbd>n</kbd>: 添加新的远程仓库
+  <kbd>d</kbd>: 删除远程
+  <kbd>e</kbd>: 编辑远程仓库
+</pre>
+
+## 分支 面板 (子提交)
+
+<pre>
+  <kbd>enter</kbd>: 查看提交的文件
+  <kbd>space</kbd>: 检出提交
+  <kbd>g</kbd>: 查看重置选项
+  <kbd>n</kbd>: 新分支
+  <kbd>c</kbd>: 复制提交（拣选）
+  <kbd>C</kbd>: 复制提交范围（拣选）
+  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
+  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
+</pre>
+
+## 分支 面板 (标签页面)
+
+<pre>
+  <kbd>space</kbd>: 检出
+  <kbd>d</kbd>: 删除标签
+  <kbd>P</kbd>: 推送标签
+  <kbd>n</kbd>: 创建标签
+  <kbd>g</kbd>: 查看重置选项
+  <kbd>enter</kbd>: 查看提交
+</pre>
+
+## 提交文件 面板
+
+<pre>
+  <kbd>ctrl+o</kbd>: 将提交的文件名复制到剪贴板
+  <kbd>c</kbd>: 检出文件
+  <kbd>d</kbd>: 放弃对此文件的提交更改
+  <kbd>o</kbd>: 打开文件
+  <kbd>e</kbd>: 编辑文件
+  <kbd>space</kbd>: 补丁中包含的切换文件
+  <kbd>enter</kbd>: 输入文件以将所选行添加到补丁中（或切换目录折叠）
+  <kbd>`</kbd>: 切换文件树视图
+</pre>
+
+## 提交 面板 (提交)
+
+<pre>
+  <kbd>ctrl+l</kbd>: open log menu
+  <kbd>s</kbd>: 向下压缩
+  <kbd>r</kbd>: 改写提交
+  <kbd>R</kbd>: 使用编辑器重命名提交
+  <kbd>g</kbd>: 重置为此提交
+  <kbd>f</kbd>: 修正提交（fixup）
+  <kbd>F</kbd>: 为此提交创建修正
+  <kbd>S</kbd>: 压缩在所选提交之上的所有“fixup!”提交（自动压缩）
+  <kbd>d</kbd>: 删除提交
+  <kbd>ctrl+j</kbd>: 下移提交
+  <kbd>ctrl+k</kbd>: 上移提交
+  <kbd>e</kbd>: 编辑提交
+  <kbd>A</kbd>: 用已暂存的更改来修补提交
+  <kbd>p</kbd>: 选择提交（变基过程中）
+  <kbd>t</kbd>: 还原提交
+  <kbd>c</kbd>: 复制提交（拣选）
+  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
+  <kbd>C</kbd>: 复制提交范围（拣选）
+  <kbd>v</kbd>: 粘贴提交（拣选）
+  <kbd>enter</kbd>: 查看提交的文件
+  <kbd>space</kbd>: 检出提交
+  <kbd>n</kbd>: 从提交创建新分支
+  <kbd>T</kbd>: 标签提交
+  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
+  <kbd>ctrl+y</kbd>: 将提交消息复制到剪贴板
+  <kbd>o</kbd>: open commit in browser
+</pre>
+
+## 提交 面板 (Reflog)
+
+<pre>
+  <kbd>enter</kbd>: 查看提交的文件
+  <kbd>space</kbd>: 检出提交
+  <kbd>g</kbd>: 查看重置选项
+  <kbd>c</kbd>: 复制提交（拣选）
+  <kbd>C</kbd>: 复制提交范围（拣选）
+  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
+  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
+</pre>
+
+## Extras 面板
+
+<pre>
+  <kbd>@</kbd>: 打开命令日志菜单
+</pre>
+
+## 文件 面板
+
+<pre>
+  <kbd>ctrl+b</kbd>: 过滤提交文件
+</pre>
+
+## 文件 面板 (文件)
+
+<pre>
+  <kbd>c</kbd>: 提交更改
+  <kbd>w</kbd>: 提交更改而无需预先提交钩子
+  <kbd>A</kbd>: 修补最后一次提交
+  <kbd>C</kbd>: 提交更改（使用编辑器编辑提交信息）
+  <kbd>space</kbd>: 切换暂存状态
+  <kbd>d</kbd>: 查看'放弃更改‘选项
+  <kbd>e</kbd>: 编辑文件
+  <kbd>o</kbd>: 打开文件
+  <kbd>i</kbd>: 添加到 .gitignore
+  <kbd>r</kbd>: 刷新文件
+  <kbd>s</kbd>: 将所有更改加入贮藏
+  <kbd>S</kbd>: 查看隐藏选项
+  <kbd>a</kbd>: 切换所有文件的暂存状态
+  <kbd>D</kbd>: 查看重置选项
+  <kbd>enter</kbd>: 暂存单个 块/行 用于文件, 或 折叠/展开 目录
+  <kbd>f</kbd>: 抓取
+  <kbd>ctrl+o</kbd>: 将文件名复制到剪贴板
+  <kbd>g</kbd>: 查看上游重置选项
+  <kbd>`</kbd>: 切换文件树视图
+  <kbd>M</kbd>: 打开合并工具
+  <kbd>ctrl+w</kbd>: 切换是否在差异视图中显示空白更改
+</pre>
+
+## 文件 面板 (子模块)
+
+<pre>
+  <kbd>ctrl+o</kbd>: 将子模块名称复制到剪贴板
+  <kbd>enter</kbd>: 输入子模块
+  <kbd>d</kbd>: 查看重置和删除子模块选项
+  <kbd>u</kbd>: 更新子模块
+  <kbd>n</kbd>: 添加新的子模块
+  <kbd>e</kbd>: 更新子模块 URL
+  <kbd>i</kbd>: 初始化子模块
+  <kbd>b</kbd>: 查看批量子模块选项
+</pre>
+
+## 主要 面板 (合并中)
+
+<pre>
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
+  <kbd>esc</kbd>: 返回文件面板
+  <kbd>M</kbd>: 打开合并工具
+  <kbd>space</kbd>: 选中区块
+  <kbd>b</kbd>: 选中所有区块
+  <kbd>◄</kbd>: 选择上一个冲突
+  <kbd>►</kbd>: 选择下一个冲突
+  <kbd>▲</kbd>: 选择顶部块
+  <kbd>▼</kbd>: 选择底部块
+  <kbd>z</kbd>: 撤销
+</pre>
+
+## 主要 面板 (正常)
+
+<pre>
+  <kbd>Ő</kbd>: 向下滚动 (fn+up)
+  <kbd>ő</kbd>: 向上滚动 (fn+down)
+</pre>
+
+## 主要 面板 (构建补丁中)
+
+<pre>
+  <kbd>esc</kbd>: 退出逐行模式
+  <kbd>o</kbd>: 打开文件
+  <kbd>▲</kbd>: 选择上一行
+  <kbd>▼</kbd>: 选择下一行
+  <kbd>◄</kbd>: 选择上一个区块
+  <kbd>►</kbd>: 选择下一个区块
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
+  <kbd>space</kbd>: 添加/移除 行到补丁
+  <kbd>v</kbd>: 切换拖动选择
+  <kbd>V</kbd>: 切换拖动选择
+  <kbd>a</kbd>: 切换选择区块
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
+</pre>
+
+## 主要 面板 (正在暂存)
+
+<pre>
+  <kbd>esc</kbd>: 返回文件面板
+  <kbd>space</kbd>: 切换行暂存状态
+  <kbd>d</kbd>: 取消变更 (git reset)
+  <kbd>tab</kbd>: 切换到其他面板
+  <kbd>o</kbd>: 打开文件
+  <kbd>▲</kbd>: 选择上一行
+  <kbd>▼</kbd>: 选择下一行
+  <kbd>◄</kbd>: 选择上一个区块
+  <kbd>►</kbd>: 选择下一个区块
+  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
+  <kbd>e</kbd>: 编辑文件
+  <kbd>o</kbd>: 打开文件
+  <kbd>v</kbd>: 切换拖动选择
+  <kbd>V</kbd>: 切换拖动选择
+  <kbd>a</kbd>: 切换选择区块
+  <kbd>H</kbd>: scroll left
+  <kbd>L</kbd>: scroll right
+  <kbd>c</kbd>: 提交更改
+  <kbd>w</kbd>: 提交更改而无需预先提交钩子
+  <kbd>C</kbd>: 提交更改（使用编辑器编辑提交信息）
+</pre>
+
+## 菜单 面板
+
+<pre>
+  <kbd>esc</kbd>: 关闭菜单
+</pre>
+
+## 贮藏 面板
+
+<pre>
+  <kbd>enter</kbd>: 查看贮藏条目中的文件
+  <kbd>space</kbd>: 应用
+  <kbd>g</kbd>: 应用并删除
+  <kbd>d</kbd>: 删除
+  <kbd>n</kbd>: 新分支
+</pre>
+
+## 状态 面板
+
+<pre>
+  <kbd>e</kbd>: 编辑配置文件
+  <kbd>o</kbd>: 打开配置文件
+  <kbd>u</kbd>: 检查更新
+  <kbd>enter</kbd>: 切换到最近的仓库
+  <kbd>a</kbd>: 显示所有分支的日志
+</pre>
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,7 @@ require (
 	github.com/imdario/mergo v0.3.11
 	github.com/integrii/flaggy v1.4.0
 	github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4
-	github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474
+	github.com/jesseduffield/gocui v0.3.1-0.20220108045521-1945d7b9ed8b
 	github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e
 	github.com/jesseduffield/yaml v2.1.0+incompatible
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
@@ -33,6 +33,7 @@ require (
 	github.com/mgutz/str v1.2.0
 	github.com/onsi/ginkgo v1.10.3 // indirect
 	github.com/onsi/gomega v1.7.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0
 	github.com/sahilm/fuzzy v0.1.0
 	github.com/sirupsen/logrus v1.4.2
 	github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad
@@ -40,7 +41,7 @@ require (
 	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778
 	golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 // indirect
 	golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c // indirect
-	golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c // indirect
+	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0
--- a/go.sum
+++ b/go.sum
@@ -71,8 +71,8 @@ github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOl
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
 github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4 h1:GOQrmaE8i+KEdB8NzAegKYd4tPn/inM0I1uo0NXFerg=
 github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4/go.mod h1:nGNEErzf+NRznT+N2SWqmHnDnF9aLgANB1CUNEan09o=
-github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474 h1:4H/oJcUmwJpqyXzqfn+lsjQ/bjpm/HszzLrVbCjgqj4=
-github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474/go.mod h1:znJuCDnF2Ph40YZSlBwdX/4GEofnIoWLGdT4mK5zRAU=
+github.com/jesseduffield/gocui v0.3.1-0.20220108045521-1945d7b9ed8b h1:AUK5nDiPiaahBtGIsf8rITgZ9SC+uddvnNKs0/mrYA8=
+github.com/jesseduffield/gocui v0.3.1-0.20220108045521-1945d7b9ed8b/go.mod h1:znJuCDnF2Ph40YZSlBwdX/4GEofnIoWLGdT4mK5zRAU=
 github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e h1:uw/oo+kg7t/oeMs6sqlAwr85ND/9cpO3up3VxphxY0U=
 github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e/go.mod h1:u60qdFGXRd36jyEXxetz0vQceQIxzI13lIo3EFUDf4I=
 github.com/jesseduffield/yaml v2.1.0+incompatible h1:HWQJ1gIv2zHKbDYNp0Jwjlj24K8aqpFHnMCynY1EpmE=
@@ -142,7 +142,6 @@ github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -178,8 +177,8 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c h1:QOfDMdrf/UwlVR0UBq2Mpr58UzNtvgJRXA4BgPfFACs=
-golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
--- a/main.go
+++ b/main.go
@@ -71,8 +71,12 @@ func main() {
 			log.Fatal("--path option is incompatible with the --work-tree and --git-dir options")
 		}

-		workTree = repoPath
-		gitDir = filepath.Join(repoPath, ".git")
+		absRepoPath, err := filepath.Abs(repoPath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		workTree = absRepoPath
+		gitDir = filepath.Join(absRepoPath, ".git")
 	}

 	if customConfig != "" {
--- a/pkg/app/app.go
+++ b/pkg/app/app.go
@@ -32,7 +32,6 @@ type App struct {
 	closers       []io.Closer
 	Config        config.AppConfigurer
 	OSCommand     *oscommands.OSCommand
-	GitCommand    *commands.GitCommand
 	Gui           *gui.Gui
 	Updater       *updates.Updater // may only need this on the Gui
 	ClientContext string
@@ -43,7 +42,7 @@ type errorMapping struct {
 	newError      string
 }

-func newProductionLogger(config config.AppConfigurer) *logrus.Logger {
+func newProductionLogger() *logrus.Logger {
 	log := logrus.New()
 	log.Out = ioutil.Discard
 	log.SetLevel(logrus.ErrorLevel)
@@ -59,7 +58,7 @@ func getLogLevel() logrus.Level {
 	return level
 }

-func newDevelopmentLogger(configurer config.AppConfigurer) *logrus.Logger {
+func newDevelopmentLogger() *logrus.Logger {
 	logger := logrus.New()
 	logger.SetLevel(getLogLevel())
 	logPath, err := config.LogPath()
@@ -68,7 +67,7 @@ func newDevelopmentLogger(configurer config.AppConfigurer) *logrus.Logger {
 	}
 	file, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 	if err != nil {
-		panic("unable to log to file") // TODO: don't panic (also, remove this call to the `panic` function)
+		log.Fatalf("Unable to log to log file: %v", err)
 	}
 	logger.SetOutput(file)
 	return logger
@@ -77,9 +76,9 @@ func newDevelopmentLogger(configurer config.AppConfigurer) *logrus.Logger {
 func newLogger(config config.AppConfigurer) *logrus.Entry {
 	var log *logrus.Logger
 	if config.GetDebug() || os.Getenv("DEBUG") == "TRUE" {
-		log = newDevelopmentLogger(config)
+		log = newDevelopmentLogger()
 	} else {
-		log = newProductionLogger(config)
+		log = newProductionLogger()
 	}

 	// highly recommended: tail -f development.log | humanlog
@@ -122,7 +121,7 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, nil
 	}

-	app.OSCommand = oscommands.NewOSCommand(app.Common)
+	app.OSCommand = oscommands.NewOSCommand(app.Common, oscommands.GetPlatform(), oscommands.NewNullGuiIO(log))

 	app.Updater, err = updates.NewUpdater(app.Common, config, app.OSCommand)
 	if err != nil {
@@ -134,16 +133,9 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, err
 	}

-	app.GitCommand, err = commands.NewGitCommand(
-		app.Common,
-		app.OSCommand,
-		git_config.NewStdCachedGitConfig(app.Log),
-	)
-	if err != nil {
-		return app, err
-	}
+	gitConfig := git_config.NewStdCachedGitConfig(app.Log)

-	app.Gui, err = gui.NewGui(app.Common, app.GitCommand, app.OSCommand, config, app.Updater, filterPath, showRecentRepos)
+	app.Gui, err = gui.NewGui(app.Common, config, gitConfig, app.Updater, filterPath, showRecentRepos)
 	if err != nil {
 		return app, err
 	}
@@ -192,7 +184,7 @@ func (app *App) setupRepo() (bool, error) {
 	}

 	if env.GetGitDirEnv() != "" {
-		// we've been given the git dir directly. We'll verify this dir when initializing our GitCommand object
+		// we've been given the git dir directly. We'll verify this dir when initializing our Git object
 		return false, nil
 	}

--- a/pkg/app/app_test.go
+++ b/pkg/app/app_test.go
@@ -36,6 +36,7 @@ func TestIsGitVersionValid(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.versionStr, func(t *testing.T) {
 			result := isGitVersionValid(s.versionStr)
 			assert.Equal(t, result, s.expectedResult)
--- a/pkg/app/logging.go
+++ b/pkg/app/logging.go
@@ -4,10 +4,11 @@
 package app

 import (
-	"github.com/aybabtme/humanlog"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
 	"log"
 	"os"
+
+	"github.com/aybabtme/humanlog"
+	"github.com/jesseduffield/lazygit/pkg/secureexec"
 )

 func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {
--- a/pkg/cheatsheet/check.go
+++ b/pkg/cheatsheet/check.go
@@ -0,0 +1,79 @@
+package cheatsheet
+
+import (
+	"fmt"
+	"io/fs"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"github.com/pmezard/go-difflib/difflib"
+)
+
+func Check() {
+	dir := GetDir()
+	tmpDir := filepath.Join(os.TempDir(), "lazygit_cheatsheet")
+	err := os.RemoveAll(tmpDir)
+	if err != nil {
+		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
+	}
+	err = os.Mkdir(tmpDir, 0700)
+	if err != nil {
+		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
+	}
+
+	generateAtDir(tmpDir)
+	defer os.RemoveAll(tmpDir)
+
+	actualContent := obtainContent(dir)
+	expectedContent := obtainContent(tmpDir)
+
+	if expectedContent == "" {
+		log.Fatal("empty expected content")
+	}
+
+	if actualContent != expectedContent {
+		err := difflib.WriteUnifiedDiff(os.Stdout, difflib.UnifiedDiff{
+			A:        difflib.SplitLines(expectedContent),
+			B:        difflib.SplitLines(actualContent),
+			FromFile: "Expected",
+			FromDate: "",
+			ToFile:   "Actual",
+			ToDate:   "",
+			Context:  1,
+		})
+		if err != nil {
+			log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
+		}
+		fmt.Printf("\nCheatsheets are out of date. Please run `%s` at the project root and commit the changes\n", CommandToRun())
+		os.Exit(1)
+	}
+
+	fmt.Println("\nCheatsheets are up to date")
+}
+
+func obtainContent(dir string) string {
+	re := regexp.MustCompile(`Keybindings_\w+\.md$`)
+
+	content := ""
+	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+		if re.MatchString(path) {
+			bytes, err := ioutil.ReadFile(path)
+			if err != nil {
+				log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
+			}
+			content += fmt.Sprintf("\n%s\n\n", filepath.Base(path))
+			content += string(bytes)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
+	}
+
+	return content
+}
--- a/scripts/generate_cheatsheet.go
+++ b/scripts/generate_cheatsheet.go
@@ -4,20 +4,21 @@
 // The content of this generated file is a keybindings cheatsheet.
 //
 // To generate cheatsheet in english run:
-//   LANG=en go run scripts/generate_cheatsheet.go
+//   go run scripts/generate_cheatsheet.go

-package main
+package cheatsheet

 import (
 	"fmt"
 	"log"
 	"os"
 	"sort"
-	"strings"

 	"github.com/jesseduffield/lazygit/pkg/app"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/gui"
+	"github.com/jesseduffield/lazygit/pkg/i18n"
+	"github.com/jesseduffield/lazygit/pkg/integration"
 )

 type bindingSection struct {
@@ -25,24 +26,41 @@ type bindingSection struct {
 	bindings []*gui.Binding
 }

-func main() {
-	langs := []string{"pl", "nl", "en"}
-	mConfig, _ := config.NewAppConfig("", "", "", "", "", true)
+func CommandToRun() string {
+	return "go run scripts/cheatsheet/main.go generate"
+}

-	for _, lang := range langs {
+func GetDir() string {
+	return integration.GetRootDirectory() + "/docs/keybindings"
+}
+
+func generateAtDir(cheatsheetDir string) {
+	os.Setenv("LANG", "en")
+
+	translationSetsByLang := i18n.GetTranslationSets()
+	mConfig := config.NewDummyAppConfig()
+
+	for lang := range translationSetsByLang {
 		os.Setenv("LC_ALL", lang)
 		mApp, _ := app.NewApp(mConfig, "")
-		file, err := os.Create(getProjectRoot() + "/docs/keybindings/Keybindings_" + lang + ".md")
+		path := cheatsheetDir + "/Keybindings_" + lang + ".md"
+		file, err := os.Create(path)
 		if err != nil {
 			panic(err)
 		}

 		bindingSections := getBindingSections(mApp)
-		content := formatSections(mApp, bindingSections)
+		content := formatSections(mApp.Tr, bindingSections)
+		content = fmt.Sprintf("# This file is auto-generated. To update, make the changes in the "+
+			"pkg/i18n directory and then run `%s` from the project root.\n\n%s", CommandToRun(), content)
 		writeString(file, content)
 	}
 }

+func Generate() {
+	generateAtDir(GetDir())
+}
+
 func writeString(file *os.File, str string) {
 	_, err := file.WriteString(str)
 	if err != nil {
@@ -231,8 +249,8 @@ func addBinding(title string, bindingSections []*bindingSection, binding *gui.Bi
 	return append(bindingSections, section)
 }

-func formatSections(mApp *app.App, bindingSections []*bindingSection) string {
-	content := fmt.Sprintf("# Lazygit %s\n", mApp.Tr.Keybindings)
+func formatSections(tr *i18n.TranslationSet, bindingSections []*bindingSection) string {
+	content := fmt.Sprintf("# Lazygit %s\n", tr.Keybindings)

 	for _, section := range bindingSections {
 		content += formatTitle(section.title)
@@ -245,11 +263,3 @@ func formatSections(mApp *app.App, bindingSections []*bindingSection) string {

 	return content
 }
-
-func getProjectRoot() string {
-	dir, err := os.Getwd()
-	if err != nil {
-		panic(err)
-	}
-	return strings.Split(dir, "lazygit")[0] + "lazygit"
-}
--- a/pkg/commands/branches.go
+++ b/pkg/commands/branches.go
@@ -1,173 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// NewBranch create new branch
-func (c *GitCommand) NewBranch(name string, base string) error {
-	return c.Cmd.New(fmt.Sprintf("git checkout -b %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(base))).Run()
-}
-
-// CurrentBranchName get the current branch name and displayname.
-// the first returned string is the name and the second is the displayname
-// e.g. name is 123asdf and displayname is '(HEAD detached at 123asdf)'
-func (c *GitCommand) CurrentBranchName() (string, string, error) {
-	branchName, err := c.Cmd.New("git symbolic-ref --short HEAD").RunWithOutput()
-	if err == nil && branchName != "HEAD\n" {
-		trimmedBranchName := strings.TrimSpace(branchName)
-		return trimmedBranchName, trimmedBranchName, nil
-	}
-	output, err := c.Cmd.New("git branch --contains").RunWithOutput()
-	if err != nil {
-		return "", "", err
-	}
-	for _, line := range utils.SplitLines(output) {
-		re := regexp.MustCompile(CurrentBranchNameRegex)
-		match := re.FindStringSubmatch(line)
-		if len(match) > 0 {
-			branchName = match[1]
-			displayBranchName := match[0][2:]
-			return branchName, displayBranchName, nil
-		}
-	}
-	return "HEAD", "HEAD", nil
-}
-
-// DeleteBranch delete branch
-func (c *GitCommand) DeleteBranch(branch string, force bool) error {
-	command := "git branch -d"
-
-	if force {
-		command = "git branch -D"
-	}
-
-	return c.Cmd.New(fmt.Sprintf("%s %s", command, c.OSCommand.Quote(branch))).Run()
-}
-
-// Checkout checks out a branch (or commit), with --force if you set the force arg to true
-type CheckoutOptions struct {
-	Force   bool
-	EnvVars []string
-}
-
-func (c *GitCommand) Checkout(branch string, options CheckoutOptions) error {
-	forceArg := ""
-	if options.Force {
-		forceArg = " --force"
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git checkout%s %s", forceArg, c.OSCommand.Quote(branch))).
-		// prevents git from prompting us for input which would freeze the program
-		// TODO: see if this is actually needed here
-		AddEnvVars("GIT_TERMINAL_PROMPT=0").
-		AddEnvVars(options.EnvVars...).
-		Run()
-}
-
-// GetBranchGraph gets the color-formatted graph of the log for the given branch
-// Currently it limits the result to 100 commits, but when we get async stuff
-// working we can do lazy loading
-func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
-	return c.GetBranchGraphCmdObj(branchName).RunWithOutput()
-}
-
-func (c *GitCommand) GetUpstreamForBranch(branchName string) (string, error) {
-	output, err := c.Cmd.New(fmt.Sprintf("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", c.OSCommand.Quote(branchName))).RunWithOutput()
-	return strings.TrimSpace(output), err
-}
-
-func (c *GitCommand) GetBranchGraphCmdObj(branchName string) oscommands.ICmdObj {
-	branchLogCmdTemplate := c.UserConfig.Git.BranchLogCmd
-	templateValues := map[string]string{
-		"branchName": c.OSCommand.Quote(branchName),
-	}
-	return c.Cmd.New(utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues))
-}
-
-func (c *GitCommand) SetUpstreamBranch(upstream string) error {
-	return c.Cmd.New("git branch -u " + c.OSCommand.Quote(upstream)).Run()
-}
-
-func (c *GitCommand) SetBranchUpstream(remoteName string, remoteBranchName string, branchName string) error {
-	return c.Cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))).Run()
-}
-
-func (c *GitCommand) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
-	return c.GetCommitDifferences("HEAD", "HEAD@{u}")
-}
-
-func (c *GitCommand) GetBranchUpstreamDifferenceCount(branchName string) (string, string) {
-	return c.GetCommitDifferences(branchName, branchName+"@{u}")
-}
-
-// GetCommitDifferences checks how many pushables/pullables there are for the
-// current branch
-func (c *GitCommand) GetCommitDifferences(from, to string) (string, string) {
-	command := "git rev-list %s..%s --count"
-	pushableCount, err := c.Cmd.New(fmt.Sprintf(command, to, from)).RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	pullableCount, err := c.Cmd.New(fmt.Sprintf(command, from, to)).RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
-}
-
-type MergeOpts struct {
-	FastForwardOnly bool
-}
-
-// Merge merge
-func (c *GitCommand) Merge(branchName string, opts MergeOpts) error {
-	mergeArg := ""
-	if c.UserConfig.Git.Merging.Args != "" {
-		mergeArg = " " + c.UserConfig.Git.Merging.Args
-	}
-
-	command := fmt.Sprintf("git merge --no-edit%s %s", mergeArg, c.OSCommand.Quote(branchName))
-	if opts.FastForwardOnly {
-		command = fmt.Sprintf("%s --ff-only", command)
-	}
-
-	return c.OSCommand.Cmd.New(command).Run()
-}
-
-// AbortMerge abort merge
-func (c *GitCommand) AbortMerge() error {
-	return c.Cmd.New("git merge --abort").Run()
-}
-
-func (c *GitCommand) IsHeadDetached() bool {
-	err := c.Cmd.New("git symbolic-ref -q HEAD").Run()
-	return err != nil
-}
-
-// ResetHardHead runs `git reset --hard`
-func (c *GitCommand) ResetHard(ref string) error {
-	return c.Cmd.New("git reset --hard " + c.OSCommand.Quote(ref)).Run()
-}
-
-// ResetSoft runs `git reset --soft HEAD`
-func (c *GitCommand) ResetSoft(ref string) error {
-	return c.Cmd.New("git reset --soft " + c.OSCommand.Quote(ref)).Run()
-}
-
-func (c *GitCommand) ResetMixed(ref string) error {
-	return c.Cmd.New("git reset --mixed " + c.OSCommand.Quote(ref)).Run()
-}
-
-func (c *GitCommand) RenameBranch(oldName string, newName string) error {
-	return c.Cmd.New(fmt.Sprintf("git branch --move %s %s", c.OSCommand.Quote(oldName), c.OSCommand.Quote(newName))).Run()
-}
-
-func (c *GitCommand) GetRawBranches() (string, error) {
-	return c.Cmd.New(`git for-each-ref --sort=-committerdate --format="%(HEAD)|%(refname:short)|%(upstream:short)|%(upstream:track)" refs/heads`).RunWithOutput()
-}
--- a/pkg/commands/commits.go
+++ b/pkg/commands/commits.go
@@ -1,105 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-// RenameCommit renames the topmost commit with the given name
-func (c *GitCommand) RenameCommit(name string) error {
-	return c.Cmd.New("git commit --allow-empty --amend --only -m " + c.OSCommand.Quote(name)).Run()
-}
-
-// ResetToCommit reset to commit
-func (c *GitCommand) ResetToCommit(sha string, strength string, envVars []string) error {
-	return c.Cmd.New(fmt.Sprintf("git reset --%s %s", strength, sha)).
-		// prevents git from prompting us for input which would freeze the program
-		// TODO: see if this is actually needed here
-		AddEnvVars("GIT_TERMINAL_PROMPT=0").
-		AddEnvVars(envVars...).
-		Run()
-}
-
-func (c *GitCommand) CommitCmdObj(message string, flags string) oscommands.ICmdObj {
-	splitMessage := strings.Split(message, "\n")
-	lineArgs := ""
-	for _, line := range splitMessage {
-		lineArgs += fmt.Sprintf(" -m %s", c.OSCommand.Quote(line))
-	}
-
-	flagsStr := ""
-	if flags != "" {
-		flagsStr = fmt.Sprintf(" %s", flags)
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git commit%s%s", flagsStr, lineArgs))
-}
-
-// Get the subject of the HEAD commit
-func (c *GitCommand) GetHeadCommitMessage() (string, error) {
-	message, err := c.Cmd.New("git log -1 --pretty=%s").RunWithOutput()
-	return strings.TrimSpace(message), err
-}
-
-func (c *GitCommand) GetCommitMessage(commitSha string) (string, error) {
-	cmdStr := "git rev-list --format=%B --max-count=1 " + commitSha
-	messageWithHeader, err := c.Cmd.New(cmdStr).RunWithOutput()
-	message := strings.Join(strings.SplitAfter(messageWithHeader, "\n")[1:], "\n")
-	return strings.TrimSpace(message), err
-}
-
-func (c *GitCommand) GetCommitMessageFirstLine(sha string) (string, error) {
-	return c.Cmd.New(fmt.Sprintf("git show --no-patch --pretty=format:%%s %s", sha)).RunWithOutput()
-}
-
-// AmendHead amends HEAD with whatever is staged in your working tree
-func (c *GitCommand) AmendHead() error {
-	return c.AmendHeadCmdObj().Run()
-}
-
-func (c *GitCommand) AmendHeadCmdObj() oscommands.ICmdObj {
-	return c.Cmd.New("git commit --amend --no-edit --allow-empty")
-}
-
-func (c *GitCommand) ShowCmdObj(sha string, filterPath string) oscommands.ICmdObj {
-	contextSize := c.UserConfig.Git.DiffContextSize
-	filterPathArg := ""
-	if filterPath != "" {
-		filterPathArg = fmt.Sprintf(" -- %s", c.OSCommand.Quote(filterPath))
-	}
-
-	cmdStr := fmt.Sprintf("git show --submodule --color=%s --unified=%d --no-renames --stat -p %s %s", c.colorArg(), contextSize, sha, filterPathArg)
-	return c.Cmd.New(cmdStr)
-}
-
-// Revert reverts the selected commit by sha
-func (c *GitCommand) Revert(sha string) error {
-	return c.Cmd.New(fmt.Sprintf("git revert %s", sha)).Run()
-}
-
-func (c *GitCommand) RevertMerge(sha string, parentNumber int) error {
-	return c.Cmd.New(fmt.Sprintf("git revert %s -m %d", sha, parentNumber)).Run()
-}
-
-// CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
-func (c *GitCommand) CherryPickCommits(commits []*models.Commit) error {
-	todo := ""
-	for _, commit := range commits {
-		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand("HEAD", todo, false)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-// CreateFixupCommit creates a commit that fixes up a previous commit
-func (c *GitCommand) CreateFixupCommit(sha string) error {
-	return c.Cmd.New(fmt.Sprintf("git commit --fixup=%s", sha)).Run()
-}
--- a/pkg/commands/commits_test.go
+++ b/pkg/commands/commits_test.go
@@ -1,134 +0,0 @@
-package commands
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandRenameCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "commit", "--allow-empty", "--amend", "--only", "-m", "test"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.RenameCommit("test"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandResetToCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "reset", "--hard", "78976bc"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.ResetToCommit("78976bc", "hard", []string{}))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandCommitObj(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-
-	type scenario struct {
-		testName string
-		message  string
-		flags    string
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "Commit",
-			message:  "test",
-			flags:    "",
-			expected: "git commit -m " + gitCmd.OSCommand.Quote("test"),
-		},
-		{
-			testName: "Commit with --no-verify flag",
-			message:  "test",
-			flags:    "--no-verify",
-			expected: "git commit --no-verify -m " + gitCmd.OSCommand.Quote("test"),
-		},
-		{
-			testName: "Commit with multiline message",
-			message:  "line1\nline2",
-			flags:    "",
-			expected: "git commit -m " + gitCmd.OSCommand.Quote("line1") + " -m " + gitCmd.OSCommand.Quote("line2"),
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			cmdStr := gitCmd.CommitCmdObj(s.message, s.flags).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
-
-func TestGitCommandCreateFixupCommit(t *testing.T) {
-	type scenario struct {
-		testName string
-		sha      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			sha:      "12345",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git commit --fixup=12345`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CreateFixupCommit(s.sha))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandShowCmdObj(t *testing.T) {
-	type scenario struct {
-		testName    string
-		filterPath  string
-		contextSize int
-		expected    string
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	scenarios := []scenario{
-		{
-			testName:    "Default case without filter path",
-			filterPath:  "",
-			contextSize: 3,
-			expected:    "git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890 ",
-		},
-		{
-			testName:    "Default case with filter path",
-			filterPath:  "file.txt",
-			contextSize: 3,
-			expected:    "git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890  -- " + gitCmd.OSCommand.Quote("file.txt"),
-		},
-		{
-			testName:    "Show diff with custom context size",
-			filterPath:  "",
-			contextSize: 77,
-			expected:    "git show --submodule --color=always --unified=77 --no-renames --stat -p 1234567890 ",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			cmdStr := gitCmd.ShowCmdObj("1234567890", s.filterPath).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
--- a/pkg/commands/config.go
+++ b/pkg/commands/config.go
@@ -1,50 +0,0 @@
-package commands
-
-import (
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func (c *GitCommand) ConfiguredPager() string {
-	if os.Getenv("GIT_PAGER") != "" {
-		return os.Getenv("GIT_PAGER")
-	}
-	if os.Getenv("PAGER") != "" {
-		return os.Getenv("PAGER")
-	}
-	output := c.GitConfig.Get("core.pager")
-	return strings.Split(output, "\n")[0]
-}
-
-func (c *GitCommand) GetPager(width int) string {
-	useConfig := c.UserConfig.Git.Paging.UseConfig
-	if useConfig {
-		pager := c.ConfiguredPager()
-		return strings.Split(pager, "| less")[0]
-	}
-
-	templateValues := map[string]string{
-		"columnWidth": strconv.Itoa(width/2 - 6),
-	}
-
-	pagerTemplate := c.UserConfig.Git.Paging.Pager
-	return utils.ResolvePlaceholderString(pagerTemplate, templateValues)
-}
-
-func (c *GitCommand) colorArg() string {
-	return c.UserConfig.Git.Paging.ColorArg
-}
-
-// UsingGpg tells us whether the user has gpg enabled so that we can know
-// whether we need to run a subprocess to allow them to enter their password
-func (c *GitCommand) UsingGpg() bool {
-	overrideGpg := c.UserConfig.Git.OverrideGpg
-	if overrideGpg {
-		return false
-	}
-
-	return c.GitConfig.GetBool("commit.gpgsign")
-}
--- a/pkg/commands/dummies.go
+++ b/pkg/commands/dummies.go
@@ -1,34 +0,0 @@
-package commands
-
-import (
-	"io"
-	"io/ioutil"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// NewDummyGitCommand creates a new dummy GitCommand for testing
-func NewDummyGitCommand() *GitCommand {
-	return NewDummyGitCommandWithOSCommand(oscommands.NewDummyOSCommand())
-}
-
-// NewDummyGitCommandWithOSCommand creates a new dummy GitCommand for testing
-func NewDummyGitCommandWithOSCommand(osCommand *oscommands.OSCommand) *GitCommand {
-	return &GitCommand{
-		Common:       utils.NewDummyCommon(),
-		OSCommand:    osCommand,
-		GitConfig:    git_config.NewFakeGitConfig(map[string]string{}),
-		GetCmdWriter: func() io.Writer { return ioutil.Discard },
-	}
-}
-
-func NewDummyGitCommandWithRunner(runner oscommands.ICmdObjRunner) *GitCommand {
-	builder := oscommands.NewDummyCmdObjBuilder(runner)
-	gitCommand := NewDummyGitCommand()
-	gitCommand.Cmd = builder
-	gitCommand.OSCommand.Cmd = builder
-
-	return gitCommand
-}
--- a/pkg/commands/files.go
+++ b/pkg/commands/files.go
@@ -1,372 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-	"time"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/gui/filetree"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// CatFile obtains the content of a file
-func (c *GitCommand) CatFile(fileName string) (string, error) {
-	buf, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return "", nil
-	}
-	return string(buf), nil
-}
-
-func (c *GitCommand) OpenMergeToolCmdObj() oscommands.ICmdObj {
-	return c.Cmd.New("git mergetool")
-}
-
-func (c *GitCommand) OpenMergeTool() error {
-	return c.OpenMergeToolCmdObj().Run()
-}
-
-// StageFile stages a file
-func (c *GitCommand) StageFile(fileName string) error {
-	return c.Cmd.New("git add -- " + c.OSCommand.Quote(fileName)).Run()
-}
-
-// StageAll stages all files
-func (c *GitCommand) StageAll() error {
-	return c.Cmd.New("git add -A").Run()
-}
-
-// UnstageAll unstages all files
-func (c *GitCommand) UnstageAll() error {
-	return c.Cmd.New("git reset").Run()
-}
-
-// UnStageFile unstages a file
-// we accept an array of filenames for the cases where a file has been renamed i.e.
-// we accept the current name and the previous name
-func (c *GitCommand) UnStageFile(fileNames []string, reset bool) error {
-	command := "git rm --cached --force -- %s"
-	if reset {
-		command = "git reset HEAD -- %s"
-	}
-
-	for _, name := range fileNames {
-		err := c.Cmd.New(fmt.Sprintf(command, c.OSCommand.Quote(name))).Run()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *GitCommand) BeforeAndAfterFileForRename(file *models.File) (*models.File, *models.File, error) {
-
-	if !file.IsRename() {
-		return nil, nil, errors.New("Expected renamed file")
-	}
-
-	// we've got a file that represents a rename from one file to another. Here we will refetch
-	// all files, passing the --no-renames flag and then recursively call the function
-	// again for the before file and after file.
-
-	filesWithoutRenames := loaders.
-		NewFileLoader(c.Common, c.Cmd, c.GitConfig).
-		GetStatusFiles(loaders.GetStatusFileOptions{NoRenames: true})
-
-	var beforeFile *models.File
-	var afterFile *models.File
-	for _, f := range filesWithoutRenames {
-		if f.Name == file.PreviousName {
-			beforeFile = f
-		}
-
-		if f.Name == file.Name {
-			afterFile = f
-		}
-	}
-
-	if beforeFile == nil || afterFile == nil {
-		return nil, nil, errors.New("Could not find deleted file or new file for file rename")
-	}
-
-	if beforeFile.IsRename() || afterFile.IsRename() {
-		// probably won't happen but we want to ensure we don't get an infinite loop
-		return nil, nil, errors.New("Nested rename found")
-	}
-
-	return beforeFile, afterFile, nil
-}
-
-// DiscardAllFileChanges directly
-func (c *GitCommand) DiscardAllFileChanges(file *models.File) error {
-	if file.IsRename() {
-		beforeFile, afterFile, err := c.BeforeAndAfterFileForRename(file)
-		if err != nil {
-			return err
-		}
-
-		if err := c.DiscardAllFileChanges(beforeFile); err != nil {
-			return err
-		}
-
-		if err := c.DiscardAllFileChanges(afterFile); err != nil {
-			return err
-		}
-
-		return nil
-	}
-
-	quotedFileName := c.OSCommand.Quote(file.Name)
-
-	if file.ShortStatus == "AA" {
-		if err := c.Cmd.New("git checkout --ours --  " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		if err := c.Cmd.New("git add -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		return nil
-	}
-
-	if file.ShortStatus == "DU" {
-		return c.Cmd.New("git rm -- " + quotedFileName).Run()
-	}
-
-	// if the file isn't tracked, we assume you want to delete it
-	if file.HasStagedChanges || file.HasMergeConflicts {
-		if err := c.Cmd.New("git reset -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-	}
-
-	if file.ShortStatus == "DD" || file.ShortStatus == "AU" {
-		return nil
-	}
-
-	if file.Added {
-		return c.OSCommand.RemoveFile(file.Name)
-	}
-	return c.DiscardUnstagedFileChanges(file)
-}
-
-func (c *GitCommand) DiscardAllDirChanges(node *filetree.FileNode) error {
-	// this could be more efficient but we would need to handle all the edge cases
-	return node.ForEachFile(c.DiscardAllFileChanges)
-}
-
-func (c *GitCommand) DiscardUnstagedDirChanges(node *filetree.FileNode) error {
-	if err := c.RemoveUntrackedDirFiles(node); err != nil {
-		return err
-	}
-
-	quotedPath := c.OSCommand.Quote(node.GetPath())
-	if err := c.Cmd.New("git checkout -- " + quotedPath).Run(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *GitCommand) RemoveUntrackedDirFiles(node *filetree.FileNode) error {
-	untrackedFilePaths := node.GetPathsMatching(
-		func(n *filetree.FileNode) bool { return n.File != nil && !n.File.GetIsTracked() },
-	)
-
-	for _, path := range untrackedFilePaths {
-		err := os.Remove(path)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// DiscardUnstagedFileChanges directly
-func (c *GitCommand) DiscardUnstagedFileChanges(file *models.File) error {
-	quotedFileName := c.OSCommand.Quote(file.Name)
-	return c.Cmd.New("git checkout -- " + quotedFileName).Run()
-}
-
-// Ignore adds a file to the gitignore for the repo
-func (c *GitCommand) Ignore(filename string) error {
-	return c.OSCommand.AppendLineToFile(".gitignore", filename)
-}
-
-// WorktreeFileDiff returns the diff of a file
-func (c *GitCommand) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string {
-	// for now we assume an error means the file was deleted
-	s, _ := c.WorktreeFileDiffCmdObj(file, plain, cached, ignoreWhitespace).RunWithOutput()
-	return s
-}
-
-func (c *GitCommand) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) oscommands.ICmdObj {
-	cachedArg := ""
-	trackedArg := "--"
-	colorArg := c.colorArg()
-	quotedPath := c.OSCommand.Quote(node.GetPath())
-	ignoreWhitespaceArg := ""
-	contextSize := c.UserConfig.Git.DiffContextSize
-	if cached {
-		cachedArg = "--cached"
-	}
-	if !node.GetIsTracked() && !node.GetHasStagedChanges() && !cached {
-		trackedArg = "--no-index -- /dev/null"
-	}
-	if plain {
-		colorArg = "never"
-	}
-	if ignoreWhitespace {
-		ignoreWhitespaceArg = "--ignore-all-space"
-	}
-
-	cmdStr := fmt.Sprintf("git diff --submodule --no-ext-diff --unified=%d --color=%s %s %s %s %s", contextSize, colorArg, ignoreWhitespaceArg, cachedArg, trackedArg, quotedPath)
-
-	return c.Cmd.New(cmdStr)
-}
-
-func (c *GitCommand) ApplyPatch(patch string, flags ...string) error {
-	filepath := filepath.Join(oscommands.GetTempDir(), utils.GetCurrentRepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".patch")
-	c.Log.Infof("saving temporary patch to %s", filepath)
-	if err := c.OSCommand.CreateFileWithContent(filepath, patch); err != nil {
-		return err
-	}
-
-	flagStr := ""
-	for _, flag := range flags {
-		flagStr += " --" + flag
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git apply%s %s", flagStr, c.OSCommand.Quote(filepath))).Run()
-}
-
-// ShowFileDiff get the diff of specified from and to. Typically this will be used for a single commit so it'll be 123abc^..123abc
-// but when we're in diff mode it could be any 'from' to any 'to'. The reverse flag is also here thanks to diff mode.
-func (c *GitCommand) ShowFileDiff(from string, to string, reverse bool, fileName string, plain bool) (string, error) {
-	return c.ShowFileDiffCmdObj(from, to, reverse, fileName, plain).RunWithOutput()
-}
-
-func (c *GitCommand) ShowFileDiffCmdObj(from string, to string, reverse bool, fileName string, plain bool) oscommands.ICmdObj {
-	colorArg := c.colorArg()
-	contextSize := c.UserConfig.Git.DiffContextSize
-	if plain {
-		colorArg = "never"
-	}
-
-	reverseFlag := ""
-	if reverse {
-		reverseFlag = " -R "
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git diff --submodule --no-ext-diff --unified=%d --no-renames --color=%s %s %s %s -- %s", contextSize, colorArg, from, to, reverseFlag, c.OSCommand.Quote(fileName)))
-}
-
-// CheckoutFile checks out the file for the given commit
-func (c *GitCommand) CheckoutFile(commitSha, fileName string) error {
-	return c.Cmd.New(fmt.Sprintf("git checkout %s -- %s", commitSha, c.OSCommand.Quote(fileName))).Run()
-}
-
-// DiscardOldFileChanges discards changes to a file from an old commit
-func (c *GitCommand) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error {
-	if err := c.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
-		return err
-	}
-
-	// check if file exists in previous commit (this command returns an error if the file doesn't exist)
-	if err := c.Cmd.New("git cat-file -e HEAD^:" + c.OSCommand.Quote(fileName)).Run(); err != nil {
-		if err := c.OSCommand.Remove(fileName); err != nil {
-			return err
-		}
-		if err := c.StageFile(fileName); err != nil {
-			return err
-		}
-	} else if err := c.CheckoutFile("HEAD^", fileName); err != nil {
-		return err
-	}
-
-	// amend the commit
-	err := c.AmendHead()
-	if err != nil {
-		return err
-	}
-
-	// continue
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-// DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`
-func (c *GitCommand) DiscardAnyUnstagedFileChanges() error {
-	return c.Cmd.New("git checkout -- .").Run()
-}
-
-// RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
-func (c *GitCommand) RemoveTrackedFiles(name string) error {
-	return c.Cmd.New("git rm -r --cached -- " + c.OSCommand.Quote(name)).Run()
-}
-
-// RemoveUntrackedFiles runs `git clean -fd`
-func (c *GitCommand) RemoveUntrackedFiles() error {
-	return c.Cmd.New("git clean -fd").Run()
-}
-
-// ResetAndClean removes all unstaged changes and removes all untracked files
-func (c *GitCommand) ResetAndClean() error {
-	submoduleConfigs, err := c.Submodules.GetConfigs()
-	if err != nil {
-		return err
-	}
-
-	if len(submoduleConfigs) > 0 {
-		if err := c.Submodules.ResetSubmodules(submoduleConfigs); err != nil {
-			return err
-		}
-	}
-
-	if err := c.ResetHard("HEAD"); err != nil {
-		return err
-	}
-
-	return c.RemoveUntrackedFiles()
-}
-
-func (c *GitCommand) EditFileCmdStr(filename string, lineNumber int) (string, error) {
-	editor := c.UserConfig.OS.EditCommand
-
-	if editor == "" {
-		editor = c.GitConfig.Get("core.editor")
-	}
-
-	if editor == "" {
-		editor = c.OSCommand.Getenv("GIT_EDITOR")
-	}
-	if editor == "" {
-		editor = c.OSCommand.Getenv("VISUAL")
-	}
-	if editor == "" {
-		editor = c.OSCommand.Getenv("EDITOR")
-	}
-	if editor == "" {
-		if err := c.OSCommand.Cmd.New("which vi").Run(); err == nil {
-			editor = "vi"
-		}
-	}
-	if editor == "" {
-		return "", errors.New("No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
-	}
-
-	templateValues := map[string]string{
-		"editor":   editor,
-		"filename": c.OSCommand.Quote(filename),
-		"line":     strconv.Itoa(lineNumber),
-	}
-
-	editCmdTemplate := c.UserConfig.OS.EditCommandTemplate
-	return utils.ResolvePlaceholderString(editCmdTemplate, templateValues), nil
-}
--- a/pkg/commands/git.go
+++ b/pkg/commands/git.go
@@ -1,7 +1,6 @@
 package commands

 import (
-	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -10,6 +9,7 @@ import (
 	"github.com/go-errors/errors"

 	gogit "github.com/jesseduffield/go-git/v5"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
@@ -19,63 +19,49 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

-// this takes something like:
-// * (HEAD detached at 264fc6f5)
-//	remotes
-// and returns '264fc6f5' as the second match
-const CurrentBranchNameRegex = `(?m)^\*.*?([^ ]*?)\)?$`
+// GitCommand is our main git interface
+type GitCommand struct {
+	Branch      *git_commands.BranchCommands
+	Commit      *git_commands.CommitCommands
+	Config      *git_commands.ConfigCommands
+	Custom      *git_commands.CustomCommands
+	File        *git_commands.FileCommands
+	Flow        *git_commands.FlowCommands
+	Patch       *git_commands.PatchCommands
+	Rebase      *git_commands.RebaseCommands
+	Remote      *git_commands.RemoteCommands
+	Stash       *git_commands.StashCommands
+	Status      *git_commands.StatusCommands
+	Submodule   *git_commands.SubmoduleCommands
+	Sync        *git_commands.SyncCommands
+	Tag         *git_commands.TagCommands
+	WorkingTree *git_commands.WorkingTreeCommands
+
+	Loaders Loaders
+}

 type Loaders struct {
-	Commits       *loaders.CommitLoader
 	Branches      *loaders.BranchLoader
-	Files         *loaders.FileLoader
 	CommitFiles   *loaders.CommitFileLoader
-	Remotes       *loaders.RemoteLoader
+	Commits       *loaders.CommitLoader
+	Files         *loaders.FileLoader
 	ReflogCommits *loaders.ReflogCommitLoader
+	Remotes       *loaders.RemoteLoader
 	Stash         *loaders.StashLoader
 	Tags          *loaders.TagLoader
 }

-// GitCommand is our main git interface
-type GitCommand struct {
-	*common.Common
-	OSCommand            *oscommands.OSCommand
-	Repo                 *gogit.Repository
-	DotGitDir            string
-	onSuccessfulContinue func() error
-	PatchManager         *patch.PatchManager
-	GitConfig            git_config.IGitConfig
-	Loaders              Loaders
-
-	// Push to current determines whether the user has configured to push to the remote branch of the same name as the current or not
-	PushToCurrent bool
-
-	// this is just a view that we write to when running certain commands.
-	// Coincidentally at the moment it's the same view that OnRunCommand logs to
-	// but that need not always be the case.
-	GetCmdWriter func() io.Writer
-
-	Cmd oscommands.ICmdObjBuilder
-
-	Submodules SubmoduleCommands
-}
-
-// NewGitCommand it runs git commands
 func NewGitCommand(
 	cmn *common.Common,
 	osCommand *oscommands.OSCommand,
 	gitConfig git_config.IGitConfig,
 ) (*GitCommand, error) {
-	var repo *gogit.Repository
-
-	pushToCurrent := gitConfig.Get("push.default") == "current"
-
 	if err := navigateToRepoRootDirectory(os.Stat, os.Chdir); err != nil {
 		return nil, err
 	}

-	var err error
-	if repo, err = setupRepository(gogit.PlainOpen, cmn.Tr.GitconfigParseErr); err != nil {
+	repo, err := setupRepository(gogit.PlainOpen, cmn.Tr.GitconfigParseErr)
+	if err != nil {
 		return nil, err
 	}

@@ -84,58 +70,82 @@ func NewGitCommand(
 		return nil, err
 	}

-	cmd := NewGitCmdObjBuilder(cmn.Log, osCommand.Cmd)
-
-	gitCommand := &GitCommand{
-		Common:        cmn,
-		OSCommand:     osCommand,
-		Repo:          repo,
-		DotGitDir:     dotGitDir,
-		PushToCurrent: pushToCurrent,
-		GitConfig:     gitConfig,
-		GetCmdWriter:  func() io.Writer { return ioutil.Discard },
-		Cmd:           cmd,
-	}
-
-	gitCommand.Loaders = Loaders{
-		Commits:       loaders.NewCommitLoader(cmn, gitCommand),
-		Branches:      loaders.NewBranchLoader(cmn, gitCommand),
-		Files:         loaders.NewFileLoader(cmn, cmd, gitConfig),
-		CommitFiles:   loaders.NewCommitFileLoader(cmn, cmd),
-		Remotes:       loaders.NewRemoteLoader(cmn, cmd, gitCommand.Repo.Remotes),
-		ReflogCommits: loaders.NewReflogCommitLoader(cmn, cmd),
-		Stash:         loaders.NewStashLoader(cmn, cmd),
-		Tags:          loaders.NewTagLoader(cmn, cmd),
-	}
-
-	gitCommand.Submodules = NewSubmoduleCommands(cmn, cmd, dotGitDir)
-
-	gitCommand.PatchManager = patch.NewPatchManager(gitCommand.Log, gitCommand.ApplyPatch, gitCommand.ShowFileDiff)
-
-	return gitCommand, nil
+	return NewGitCommandAux(
+		cmn,
+		osCommand,
+		gitConfig,
+		dotGitDir,
+		repo,
+	), nil
 }

-func (c *GitCommand) WithSpan(span string) *GitCommand {
-	// sometimes .WithSpan(span) will be called where span actually is empty, in
-	// which case we don't need to log anything so we can just return early here
-	// with the original struct
-	if span == "" {
-		return c
+func NewGitCommandAux(
+	cmn *common.Common,
+	osCommand *oscommands.OSCommand,
+	gitConfig git_config.IGitConfig,
+	dotGitDir string,
+	repo *gogit.Repository,
+) *GitCommand {
+	cmd := NewGitCmdObjBuilder(cmn.Log, osCommand.Cmd)
+
+	// here we're doing a bunch of dependency injection for each of our commands structs.
+	// This is admittedly messy, but allows us to test each command struct in isolation,
+	// and allows for better namespacing when compared to having every method living
+	// on the one struct.
+	configCommands := git_commands.NewConfigCommands(cmn, gitConfig, repo)
+	statusCommands := git_commands.NewStatusCommands(cmn, osCommand, repo, dotGitDir)
+	fileLoader := loaders.NewFileLoader(cmn, cmd, configCommands)
+	flowCommands := git_commands.NewFlowCommands(cmn, cmd, configCommands)
+	remoteCommands := git_commands.NewRemoteCommands(cmn, cmd)
+	branchCommands := git_commands.NewBranchCommands(cmn, cmd)
+	syncCommands := git_commands.NewSyncCommands(cmn, cmd)
+	tagCommands := git_commands.NewTagCommands(cmn, cmd)
+	commitCommands := git_commands.NewCommitCommands(cmn, cmd)
+	customCommands := git_commands.NewCustomCommands(cmn, cmd)
+	fileCommands := git_commands.NewFileCommands(cmn, cmd, configCommands, osCommand)
+	submoduleCommands := git_commands.NewSubmoduleCommands(cmn, cmd, dotGitDir)
+	workingTreeCommands := git_commands.NewWorkingTreeCommands(cmn, cmd, submoduleCommands, osCommand, fileLoader)
+	rebaseCommands := git_commands.NewRebaseCommands(
+		cmn,
+		cmd,
+		osCommand,
+		commitCommands,
+		workingTreeCommands,
+		configCommands,
+		dotGitDir,
+	)
+	stashCommands := git_commands.NewStashCommands(cmn, cmd, osCommand, fileLoader, workingTreeCommands)
+	// TODO: have patch manager take workingTreeCommands in its entirety
+	patchManager := patch.NewPatchManager(cmn.Log, workingTreeCommands.ApplyPatch, workingTreeCommands.ShowFileDiff)
+	patchCommands := git_commands.NewPatchCommands(cmn, cmd, rebaseCommands, commitCommands, configCommands, statusCommands, patchManager)
+
+	return &GitCommand{
+		Branch:      branchCommands,
+		Commit:      commitCommands,
+		Config:      configCommands,
+		Custom:      customCommands,
+		File:        fileCommands,
+		Flow:        flowCommands,
+		Patch:       patchCommands,
+		Rebase:      rebaseCommands,
+		Remote:      remoteCommands,
+		Stash:       stashCommands,
+		Status:      statusCommands,
+		Submodule:   submoduleCommands,
+		Sync:        syncCommands,
+		Tag:         tagCommands,
+		WorkingTree: workingTreeCommands,
+		Loaders: Loaders{
+			Branches:      loaders.NewBranchLoader(cmn, branchCommands.GetRawBranches, branchCommands.CurrentBranchName, configCommands),
+			CommitFiles:   loaders.NewCommitFileLoader(cmn, cmd),
+			Commits:       loaders.NewCommitLoader(cmn, cmd, dotGitDir, branchCommands.CurrentBranchName, statusCommands.RebaseMode),
+			Files:         fileLoader,
+			ReflogCommits: loaders.NewReflogCommitLoader(cmn, cmd),
+			Remotes:       loaders.NewRemoteLoader(cmn, cmd, repo.Remotes),
+			Stash:         loaders.NewStashLoader(cmn, cmd),
+			Tags:          loaders.NewTagLoader(cmn, cmd),
+		},
 	}
-
-	newGitCommand := &GitCommand{}
-	*newGitCommand = *c
-	newGitCommand.OSCommand = c.OSCommand.WithSpan(span)
-
-	newGitCommand.Cmd = NewGitCmdObjBuilder(c.Log, newGitCommand.OSCommand.Cmd)
-
-	// NOTE: unlike the other things here which create shallow clones, this will
-	// actually update the PatchManager on the original struct to have the new span.
-	// This means each time we call ApplyPatch in PatchManager, we need to ensure
-	// we've called .WithSpan() ahead of time with the new span value
-	newGitCommand.PatchManager.ApplyPatch = newGitCommand.ApplyPatch
-
-	return newGitCommand
 }

 func navigateToRepoRootDirectory(stat func(string) (os.FileInfo, error), chdir func(string) error) error {
@@ -249,13 +259,5 @@ func findDotGitDir(stat func(string) (os.FileInfo, error), readFile func(filenam
 }

 func VerifyInGitRepo(osCommand *oscommands.OSCommand) error {
-	return osCommand.Cmd.New("git rev-parse --git-dir").Run()
-}
-
-func (c *GitCommand) GetDotGitDir() string {
-	return c.DotGitDir
-}
-
-func (c *GitCommand) GetCmd() oscommands.ICmdObjBuilder {
-	return c.Cmd
+	return osCommand.Cmd.New("git rev-parse --git-dir").DontLog().Run()
 }
--- a/pkg/commands/git_commands/branch.go
+++ b/pkg/commands/git_commands/branch.go
@@ -0,0 +1,175 @@
+package git_commands
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+// this takes something like:
+// * (HEAD detached at 264fc6f5)
+//	remotes
+// and returns '264fc6f5' as the second match
+const CurrentBranchNameRegex = `(?m)^\*.*?([^ ]*?)\)?$`
+
+type BranchCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewBranchCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *BranchCommands {
+	return &BranchCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+// New creates a new branch
+func (self *BranchCommands) New(name string, base string) error {
+	return self.cmd.New(fmt.Sprintf("git checkout -b %s %s", self.cmd.Quote(name), self.cmd.Quote(base))).Run()
+}
+
+// CurrentBranchName get the current branch name and displayname.
+// the first returned string is the name and the second is the displayname
+// e.g. name is 123asdf and displayname is '(HEAD detached at 123asdf)'
+func (self *BranchCommands) CurrentBranchName() (string, string, error) {
+	branchName, err := self.cmd.New("git symbolic-ref --short HEAD").DontLog().RunWithOutput()
+	if err == nil && branchName != "HEAD\n" {
+		trimmedBranchName := strings.TrimSpace(branchName)
+		return trimmedBranchName, trimmedBranchName, nil
+	}
+	output, err := self.cmd.New("git branch --contains").DontLog().RunWithOutput()
+	if err != nil {
+		return "", "", err
+	}
+	for _, line := range utils.SplitLines(output) {
+		re := regexp.MustCompile(CurrentBranchNameRegex)
+		match := re.FindStringSubmatch(line)
+		if len(match) > 0 {
+			branchName = match[1]
+			displayBranchName := match[0][2:]
+			return branchName, displayBranchName, nil
+		}
+	}
+	return "HEAD", "HEAD", nil
+}
+
+// Delete delete branch
+func (self *BranchCommands) Delete(branch string, force bool) error {
+	command := "git branch -d"
+
+	if force {
+		command = "git branch -D"
+	}
+
+	return self.cmd.New(fmt.Sprintf("%s %s", command, self.cmd.Quote(branch))).Run()
+}
+
+// Checkout checks out a branch (or commit), with --force if you set the force arg to true
+type CheckoutOptions struct {
+	Force   bool
+	EnvVars []string
+}
+
+func (self *BranchCommands) Checkout(branch string, options CheckoutOptions) error {
+	forceArg := ""
+	if options.Force {
+		forceArg = " --force"
+	}
+
+	return self.cmd.New(fmt.Sprintf("git checkout%s %s", forceArg, self.cmd.Quote(branch))).
+		// prevents git from prompting us for input which would freeze the program
+		// TODO: see if this is actually needed here
+		AddEnvVars("GIT_TERMINAL_PROMPT=0").
+		AddEnvVars(options.EnvVars...).
+		Run()
+}
+
+// GetGraph gets the color-formatted graph of the log for the given branch
+// Currently it limits the result to 100 commits, but when we get async stuff
+// working we can do lazy loading
+func (self *BranchCommands) GetGraph(branchName string) (string, error) {
+	return self.GetGraphCmdObj(branchName).DontLog().RunWithOutput()
+}
+
+func (self *BranchCommands) GetGraphCmdObj(branchName string) oscommands.ICmdObj {
+	branchLogCmdTemplate := self.UserConfig.Git.BranchLogCmd
+	templateValues := map[string]string{
+		"branchName": self.cmd.Quote(branchName),
+	}
+	return self.cmd.New(utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues)).DontLog()
+}
+
+func (self *BranchCommands) SetCurrentBranchUpstream(remoteName string, remoteBranchName string) error {
+	return self.cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName))).Run()
+}
+
+func (self *BranchCommands) SetUpstream(remoteName string, remoteBranchName string, branchName string) error {
+	return self.cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s %s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName), self.cmd.Quote(branchName))).Run()
+}
+
+func (self *BranchCommands) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
+	return self.GetCommitDifferences("HEAD", "HEAD@{u}")
+}
+
+func (self *BranchCommands) GetUpstreamDifferenceCount(branchName string) (string, string) {
+	return self.GetCommitDifferences(branchName, branchName+"@{u}")
+}
+
+// GetCommitDifferences checks how many pushables/pullables there are for the
+// current branch
+func (self *BranchCommands) GetCommitDifferences(from, to string) (string, string) {
+	command := "git rev-list %s..%s --count"
+	pushableCount, err := self.cmd.New(fmt.Sprintf(command, to, from)).DontLog().RunWithOutput()
+	if err != nil {
+		return "?", "?"
+	}
+	pullableCount, err := self.cmd.New(fmt.Sprintf(command, from, to)).DontLog().RunWithOutput()
+	if err != nil {
+		return "?", "?"
+	}
+	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
+}
+
+func (self *BranchCommands) IsHeadDetached() bool {
+	err := self.cmd.New("git symbolic-ref -q HEAD").DontLog().Run()
+	return err != nil
+}
+
+func (self *BranchCommands) Rename(oldName string, newName string) error {
+	return self.cmd.New(fmt.Sprintf("git branch --move %s %s", self.cmd.Quote(oldName), self.cmd.Quote(newName))).Run()
+}
+
+func (self *BranchCommands) GetRawBranches() (string, error) {
+	return self.cmd.New(`git for-each-ref --sort=-committerdate --format="%(HEAD)|%(refname:short)|%(upstream:short)|%(upstream:track)" refs/heads`).DontLog().RunWithOutput()
+}
+
+type MergeOpts struct {
+	FastForwardOnly bool
+}
+
+func (self *BranchCommands) Merge(branchName string, opts MergeOpts) error {
+	mergeArg := ""
+	if self.UserConfig.Git.Merging.Args != "" {
+		mergeArg = " " + self.UserConfig.Git.Merging.Args
+	}
+
+	command := fmt.Sprintf("git merge --no-edit%s %s", mergeArg, self.cmd.Quote(branchName))
+	if opts.FastForwardOnly {
+		command = fmt.Sprintf("%s --ff-only", command)
+	}
+
+	return self.cmd.New(command).Run()
+}
+
+func (self *BranchCommands) AllBranchesLogCmdObj() oscommands.ICmdObj {
+	return self.cmd.New(self.UserConfig.Git.AllBranchesLogCmd).DontLog()
+}
--- a/pkg/commands/git_commands/branch_test.go
+++ b/pkg/commands/git_commands/branch_test.go
@@ -1,14 +1,20 @@
-package commands
+package git_commands

 import (
 	"testing"

 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/stretchr/testify/assert"
 )

-func TestGitCommandGetCommitDifferences(t *testing.T) {
+func NewBranchCommandsWithRunner(runner *oscommands.FakeCmdObjRunner) *BranchCommands {
+	builder := oscommands.NewDummyCmdObjBuilder(runner)
+	return NewBranchCommands(utils.NewDummyCommon(), builder)
+}
+
+func TestBranchGetCommitDifferences(t *testing.T) {
 	type scenario struct {
 		testName          string
 		runner            *oscommands.FakeCmdObjRunner
@@ -40,9 +46,10 @@ func TestGitCommandGetCommitDifferences(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			pushables, pullables := gitCmd.GetCommitDifferences("HEAD", "@{u}")
+			instance := NewBranchCommandsWithRunner(s.runner)
+			pushables, pullables := instance.GetCommitDifferences("HEAD", "@{u}")
 			assert.EqualValues(t, s.expectedPushables, pushables)
 			assert.EqualValues(t, s.expectedPullables, pullables)
 			s.runner.CheckForMissingCalls()
@@ -50,16 +57,16 @@ func TestGitCommandGetCommitDifferences(t *testing.T) {
 	}
 }

-func TestGitCommandNewBranch(t *testing.T) {
+func TestBranchNewBranch(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
 		Expect(`git checkout -b "test" "master"`, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
+	instance := NewBranchCommandsWithRunner(runner)

-	assert.NoError(t, gitCmd.NewBranch("test", "master"))
+	assert.NoError(t, instance.New("test", "master"))
 	runner.CheckForMissingCalls()
 }

-func TestGitCommandDeleteBranch(t *testing.T) {
+func TestBranchDeleteBranch(t *testing.T) {
 	type scenario struct {
 		testName string
 		force    bool
@@ -87,25 +94,26 @@ func TestGitCommandDeleteBranch(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			instance := NewBranchCommandsWithRunner(s.runner)

-			s.test(gitCmd.DeleteBranch("test", s.force))
+			s.test(instance.Delete("test", s.force))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandMerge(t *testing.T) {
+func TestBranchMerge(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
 		Expect(`git merge --no-edit "test"`, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
+	instance := NewBranchCommandsWithRunner(runner)

-	assert.NoError(t, gitCmd.Merge("test", MergeOpts{}))
+	assert.NoError(t, instance.Merge("test", MergeOpts{}))
 	runner.CheckForMissingCalls()
 }

-func TestGitCommandCheckout(t *testing.T) {
+func TestBranchCheckout(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -133,34 +141,34 @@ func TestGitCommandCheckout(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.Checkout("test", CheckoutOptions{Force: s.force}))
+			instance := NewBranchCommandsWithRunner(s.runner)
+			s.test(instance.Checkout("test", CheckoutOptions{Force: s.force}))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandGetBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectArgs([]string{
-		"git", "log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--",
+func TestBranchGetBranchGraph(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).ExpectGitArgs([]string{
+		"log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--",
 	}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-	_, err := gitCmd.GetBranchGraph("test")
+	instance := NewBranchCommandsWithRunner(runner)
+	_, err := instance.GetGraph("test")
 	assert.NoError(t, err)
 }

-func TestGitCommandGetAllBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectArgs([]string{
-		"git", "log", "--graph", "--all", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium",
+func TestBranchGetAllBranchGraph(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).ExpectGitArgs([]string{
+		"log", "--graph", "--all", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium",
 	}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-	cmdStr := gitCmd.UserConfig.Git.AllBranchesLogCmd
-	_, err := gitCmd.Cmd.New(cmdStr).RunWithOutput()
+	instance := NewBranchCommandsWithRunner(runner)
+	err := instance.AllBranchesLogCmdObj().Run()
 	assert.NoError(t, err)
 }

-func TestGitCommandCurrentBranchName(t *testing.T) {
+func TestBranchCurrentBranchName(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -213,38 +221,11 @@ func TestGitCommandCurrentBranchName(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CurrentBranchName())
+			instance := NewBranchCommandsWithRunner(s.runner)
+			s.test(instance.CurrentBranchName())
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
-
-func TestGitCommandResetHard(t *testing.T) {
-	type scenario struct {
-		testName string
-		ref      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			"HEAD",
-			oscommands.NewFakeRunner(t).
-				Expect(`git reset --hard "HEAD"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.ResetHard(s.ref))
-		})
-	}
-}
--- a/pkg/commands/git_commands/commit.go
+++ b/pkg/commands/git_commands/commit.go
@@ -0,0 +1,120 @@
+package git_commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type CommitCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewCommitCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *CommitCommands {
+	return &CommitCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+// RewordLastCommit rewords the topmost commit with the given message
+func (self *CommitCommands) RewordLastCommit(message string) error {
+	return self.cmd.New("git commit --allow-empty --amend --only -m " + self.cmd.Quote(message)).Run()
+}
+
+// ResetToCommit reset to commit
+func (self *CommitCommands) ResetToCommit(sha string, strength string, envVars []string) error {
+	return self.cmd.New(fmt.Sprintf("git reset --%s %s", strength, sha)).
+		// prevents git from prompting us for input which would freeze the program
+		// TODO: see if this is actually needed here
+		AddEnvVars("GIT_TERMINAL_PROMPT=0").
+		AddEnvVars(envVars...).
+		Run()
+}
+
+func (self *CommitCommands) CommitCmdObj(message string) oscommands.ICmdObj {
+	splitMessage := strings.Split(message, "\n")
+	lineArgs := ""
+	for _, line := range splitMessage {
+		lineArgs += fmt.Sprintf(" -m %s", self.cmd.Quote(line))
+	}
+
+	skipHookPrefix := self.UserConfig.Git.SkipHookPrefix
+	noVerifyFlag := ""
+	if skipHookPrefix != "" && strings.HasPrefix(message, skipHookPrefix) {
+		noVerifyFlag = " --no-verify"
+	}
+
+	return self.cmd.New(fmt.Sprintf("git commit%s%s%s", noVerifyFlag, self.signoffFlag(), lineArgs))
+}
+
+// runs git commit without the -m argument meaning it will invoke the user's editor
+func (self *CommitCommands) CommitEditorCmdObj() oscommands.ICmdObj {
+	return self.cmd.New(fmt.Sprintf("git commit%s", self.signoffFlag()))
+}
+
+func (self *CommitCommands) signoffFlag() string {
+	if self.UserConfig.Git.Commit.SignOff {
+		return " --signoff"
+	} else {
+		return ""
+	}
+}
+
+// Get the subject of the HEAD commit
+func (self *CommitCommands) GetHeadCommitMessage() (string, error) {
+	message, err := self.cmd.New("git log -1 --pretty=%s").DontLog().RunWithOutput()
+	return strings.TrimSpace(message), err
+}
+
+func (self *CommitCommands) GetCommitMessage(commitSha string) (string, error) {
+	cmdStr := "git rev-list --format=%B --max-count=1 " + commitSha
+	messageWithHeader, err := self.cmd.New(cmdStr).DontLog().RunWithOutput()
+	message := strings.Join(strings.SplitAfter(messageWithHeader, "\n")[1:], "\n")
+	return strings.TrimSpace(message), err
+}
+
+func (self *CommitCommands) GetCommitMessageFirstLine(sha string) (string, error) {
+	return self.cmd.New(fmt.Sprintf("git show --no-patch --pretty=format:%%s %s", sha)).DontLog().RunWithOutput()
+}
+
+// AmendHead amends HEAD with whatever is staged in your working tree
+func (self *CommitCommands) AmendHead() error {
+	return self.AmendHeadCmdObj().Run()
+}
+
+func (self *CommitCommands) AmendHeadCmdObj() oscommands.ICmdObj {
+	return self.cmd.New("git commit --amend --no-edit --allow-empty")
+}
+
+func (self *CommitCommands) ShowCmdObj(sha string, filterPath string) oscommands.ICmdObj {
+	contextSize := self.UserConfig.Git.DiffContextSize
+	filterPathArg := ""
+	if filterPath != "" {
+		filterPathArg = fmt.Sprintf(" -- %s", self.cmd.Quote(filterPath))
+	}
+
+	cmdStr := fmt.Sprintf("git show --submodule --color=%s --unified=%d --no-renames --stat -p %s %s", self.UserConfig.Git.Paging.ColorArg, contextSize, sha, filterPathArg)
+	return self.cmd.New(cmdStr).DontLog()
+}
+
+// Revert reverts the selected commit by sha
+func (self *CommitCommands) Revert(sha string) error {
+	return self.cmd.New(fmt.Sprintf("git revert %s", sha)).Run()
+}
+
+func (self *CommitCommands) RevertMerge(sha string, parentNumber int) error {
+	return self.cmd.New(fmt.Sprintf("git revert %s -m %d", sha, parentNumber)).Run()
+}
+
+// CreateFixupCommit creates a commit that fixes up a previous commit
+func (self *CommitCommands) CreateFixupCommit(sha string) error {
+	return self.cmd.New(fmt.Sprintf("git commit --fixup=%s", sha)).Run()
+}
--- a/pkg/commands/git_commands/commit_test.go
+++ b/pkg/commands/git_commands/commit_test.go
@@ -0,0 +1,163 @@
+package git_commands
+
+import (
+	"testing"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommitRewordCommit(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"commit", "--allow-empty", "--amend", "--only", "-m", "test"}, "", nil)
+	instance := buildCommitCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.RewordLastCommit("test"))
+	runner.CheckForMissingCalls()
+}
+
+func TestCommitResetToCommit(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"reset", "--hard", "78976bc"}, "", nil)
+
+	instance := buildCommitCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.ResetToCommit("78976bc", "hard", []string{}))
+	runner.CheckForMissingCalls()
+}
+
+func TestCommitCommitObj(t *testing.T) {
+	type scenario struct {
+		testName             string
+		message              string
+		configSignoff        bool
+		configSkipHookPrefix string
+		expected             string
+	}
+
+	scenarios := []scenario{
+		{
+			testName:             "Commit",
+			message:              "test",
+			configSignoff:        false,
+			configSkipHookPrefix: "",
+			expected:             `git commit -m "test"`,
+		},
+		{
+			testName:             "Commit with --no-verify flag",
+			message:              "WIP: test",
+			configSignoff:        false,
+			configSkipHookPrefix: "WIP",
+			expected:             `git commit --no-verify -m "WIP: test"`,
+		},
+		{
+			testName:             "Commit with multiline message",
+			message:              "line1\nline2",
+			configSignoff:        false,
+			configSkipHookPrefix: "",
+			expected:             `git commit -m "line1" -m "line2"`,
+		},
+		{
+			testName:             "Commit with signoff",
+			message:              "test",
+			configSignoff:        true,
+			configSkipHookPrefix: "",
+			expected:             `git commit --signoff -m "test"`,
+		},
+		{
+			testName:             "Commit with signoff and no-verify",
+			message:              "WIP: test",
+			configSignoff:        true,
+			configSkipHookPrefix: "WIP",
+			expected:             `git commit --no-verify --signoff -m "WIP: test"`,
+		},
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			userConfig := config.GetDefaultConfig()
+			userConfig.Git.Commit.SignOff = s.configSignoff
+			userConfig.Git.SkipHookPrefix = s.configSkipHookPrefix
+
+			instance := buildCommitCommands(commonDeps{userConfig: userConfig})
+
+			cmdStr := instance.CommitCmdObj(s.message).ToString()
+			assert.Equal(t, s.expected, cmdStr)
+		})
+	}
+}
+
+func TestCommitCreateFixupCommit(t *testing.T) {
+	type scenario struct {
+		testName string
+		sha      string
+		runner   *oscommands.FakeCmdObjRunner
+		test     func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			testName: "valid case",
+			sha:      "12345",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git commit --fixup=12345`, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			instance := buildCommitCommands(commonDeps{runner: s.runner})
+			s.test(instance.CreateFixupCommit(s.sha))
+			s.runner.CheckForMissingCalls()
+		})
+	}
+}
+
+func TestCommitShowCmdObj(t *testing.T) {
+	type scenario struct {
+		testName    string
+		filterPath  string
+		contextSize int
+		expected    string
+	}
+
+	scenarios := []scenario{
+		{
+			testName:    "Default case without filter path",
+			filterPath:  "",
+			contextSize: 3,
+			expected:    "git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890 ",
+		},
+		{
+			testName:    "Default case with filter path",
+			filterPath:  "file.txt",
+			contextSize: 3,
+			expected:    `git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890  -- "file.txt"`,
+		},
+		{
+			testName:    "Show diff with custom context size",
+			filterPath:  "",
+			contextSize: 77,
+			expected:    "git show --submodule --color=always --unified=77 --no-renames --stat -p 1234567890 ",
+		},
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			userConfig := config.GetDefaultConfig()
+			userConfig.Git.DiffContextSize = s.contextSize
+
+			instance := buildCommitCommands(commonDeps{userConfig: userConfig})
+
+			cmdStr := instance.ShowCmdObj("1234567890", s.filterPath).ToString()
+			assert.Equal(t, s.expected, cmdStr)
+		})
+	}
+}
--- a/pkg/commands/git_commands/config.go
+++ b/pkg/commands/git_commands/config.go
@@ -0,0 +1,101 @@
+package git_commands
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	gogit "github.com/jesseduffield/go-git/v5"
+	"github.com/jesseduffield/go-git/v5/config"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
+	"github.com/jesseduffield/lazygit/pkg/common"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+type ConfigCommands struct {
+	*common.Common
+
+	gitConfig git_config.IGitConfig
+	repo      *gogit.Repository
+}
+
+func NewConfigCommands(
+	common *common.Common,
+	gitConfig git_config.IGitConfig,
+	repo *gogit.Repository,
+) *ConfigCommands {
+	return &ConfigCommands{
+		Common:    common,
+		gitConfig: gitConfig,
+		repo:      repo,
+	}
+}
+
+func (self *ConfigCommands) ConfiguredPager() string {
+	if os.Getenv("GIT_PAGER") != "" {
+		return os.Getenv("GIT_PAGER")
+	}
+	if os.Getenv("PAGER") != "" {
+		return os.Getenv("PAGER")
+	}
+	output := self.gitConfig.Get("core.pager")
+	return strings.Split(output, "\n")[0]
+}
+
+func (self *ConfigCommands) GetPager(width int) string {
+	useConfig := self.UserConfig.Git.Paging.UseConfig
+	if useConfig {
+		pager := self.ConfiguredPager()
+		return strings.Split(pager, "| less")[0]
+	}
+
+	templateValues := map[string]string{
+		"columnWidth": strconv.Itoa(width/2 - 6),
+	}
+
+	pagerTemplate := self.UserConfig.Git.Paging.Pager
+	return utils.ResolvePlaceholderString(pagerTemplate, templateValues)
+}
+
+// UsingGpg tells us whether the user has gpg enabled so that we can know
+// whether we need to run a subprocess to allow them to enter their password
+func (self *ConfigCommands) UsingGpg() bool {
+	overrideGpg := self.UserConfig.Git.OverrideGpg
+	if overrideGpg {
+		return false
+	}
+
+	return self.gitConfig.GetBool("commit.gpgsign")
+}
+
+func (self *ConfigCommands) GetCoreEditor() string {
+	return self.gitConfig.Get("core.editor")
+}
+
+// GetRemoteURL returns current repo remote url
+func (self *ConfigCommands) GetRemoteURL() string {
+	return self.gitConfig.Get("remote.origin.url")
+}
+
+func (self *ConfigCommands) GetShowUntrackedFiles() string {
+	return self.gitConfig.Get("status.showUntrackedFiles")
+}
+
+// this determines whether the user has configured to push to the remote branch of the same name as the current or not
+func (self *ConfigCommands) GetPushToCurrent() bool {
+	return self.gitConfig.Get("push.default") == "current"
+}
+
+// returns the repo's branches as specified in the git config
+func (self *ConfigCommands) Branches() (map[string]*config.Branch, error) {
+	conf, err := self.repo.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	return conf.Branches, nil
+}
+
+func (self *ConfigCommands) GetGitFlowPrefixes() string {
+	return self.gitConfig.GetGeneral("--local --get-regexp gitflow.prefix")
+}
--- a/pkg/commands/git_commands/custom.go
+++ b/pkg/commands/git_commands/custom.go
@@ -0,0 +1,29 @@
+package git_commands
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type CustomCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewCustomCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *CustomCommands {
+	return &CustomCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+// Only to be used for the sake of running custom commands specified by the user.
+// If you want to run a new command, try finding a place for it in one of the neighbouring
+// files, or creating a new BlahCommands struct to hold it.
+func (self *CustomCommands) RunWithOutput(cmdStr string) (string, error) {
+	return self.cmd.New(cmdStr).RunWithOutput()
+}
--- a/pkg/commands/git_commands/deps_test.go
+++ b/pkg/commands/git_commands/deps_test.go
@@ -0,0 +1,141 @@
+package git_commands
+
+import (
+	"github.com/go-errors/errors"
+	gogit "github.com/jesseduffield/go-git/v5"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
+	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+type commonDeps struct {
+	runner     *oscommands.FakeCmdObjRunner
+	userConfig *config.UserConfig
+	gitConfig  *git_config.FakeGitConfig
+	getenv     func(string) string
+	removeFile func(string) error
+	dotGitDir  string
+	common     *common.Common
+	cmd        *oscommands.CmdObjBuilder
+}
+
+func completeDeps(deps commonDeps) commonDeps {
+	if deps.runner == nil {
+		deps.runner = oscommands.NewFakeRunner(nil)
+	}
+
+	if deps.userConfig == nil {
+		deps.userConfig = config.GetDefaultConfig()
+	}
+
+	if deps.gitConfig == nil {
+		deps.gitConfig = git_config.NewFakeGitConfig(nil)
+	}
+
+	if deps.getenv == nil {
+		deps.getenv = func(string) string { return "" }
+	}
+
+	if deps.removeFile == nil {
+		deps.removeFile = func(string) error { return errors.New("unexpected call to removeFile") }
+	}
+
+	if deps.dotGitDir == "" {
+		deps.dotGitDir = ".git"
+	}
+
+	if deps.common == nil {
+		deps.common = utils.NewDummyCommonWithUserConfig(deps.userConfig)
+	}
+
+	if deps.cmd == nil {
+		deps.cmd = oscommands.NewDummyCmdObjBuilder(deps.runner)
+	}
+
+	return deps
+}
+
+func buildConfigCommands(deps commonDeps) *ConfigCommands {
+	deps = completeDeps(deps)
+	common := utils.NewDummyCommonWithUserConfig(deps.userConfig)
+
+	// TODO: think of a way to actually mock this outnil
+	var repo *gogit.Repository = nil
+
+	return NewConfigCommands(common, deps.gitConfig, repo)
+}
+
+func buildOSCommand(deps commonDeps) *oscommands.OSCommand {
+	deps = completeDeps(deps)
+
+	return oscommands.NewDummyOSCommandWithDeps(oscommands.OSCommandDeps{
+		Common:       deps.common,
+		GetenvFn:     deps.getenv,
+		Cmd:          deps.cmd,
+		RemoveFileFn: deps.removeFile,
+	})
+}
+
+func buildFileLoader(deps commonDeps) *loaders.FileLoader {
+	deps = completeDeps(deps)
+
+	configCommands := buildConfigCommands(deps)
+
+	return loaders.NewFileLoader(deps.common, deps.cmd, configCommands)
+}
+
+func buildSubmoduleCommands(deps commonDeps) *SubmoduleCommands {
+	deps = completeDeps(deps)
+
+	return NewSubmoduleCommands(deps.common, deps.cmd, deps.dotGitDir)
+}
+
+func buildCommitCommands(deps commonDeps) *CommitCommands {
+	deps = completeDeps(deps)
+	return NewCommitCommands(deps.common, deps.cmd)
+}
+
+func buildWorkingTreeCommands(deps commonDeps) *WorkingTreeCommands {
+	deps = completeDeps(deps)
+	osCommand := buildOSCommand(deps)
+	submoduleCommands := buildSubmoduleCommands(deps)
+	fileLoader := buildFileLoader(deps)
+
+	return NewWorkingTreeCommands(deps.common, deps.cmd, submoduleCommands, osCommand, fileLoader)
+}
+
+func buildStashCommands(deps commonDeps) *StashCommands {
+	deps = completeDeps(deps)
+	osCommand := buildOSCommand(deps)
+	fileLoader := buildFileLoader(deps)
+	workingTreeCommands := buildWorkingTreeCommands(deps)
+
+	return NewStashCommands(deps.common, deps.cmd, osCommand, fileLoader, workingTreeCommands)
+}
+
+func buildRebaseCommands(deps commonDeps) *RebaseCommands {
+	deps = completeDeps(deps)
+	configCommands := buildConfigCommands(deps)
+	osCommand := buildOSCommand(deps)
+	workingTreeCommands := buildWorkingTreeCommands(deps)
+	commitCommands := buildCommitCommands(deps)
+
+	return NewRebaseCommands(deps.common, deps.cmd, osCommand, commitCommands, workingTreeCommands, configCommands, deps.dotGitDir)
+}
+
+func buildSyncCommands(deps commonDeps) *SyncCommands {
+	deps = completeDeps(deps)
+
+	return NewSyncCommands(deps.common, deps.cmd)
+}
+
+func buildFileCommands(deps commonDeps) *FileCommands {
+	deps = completeDeps(deps)
+	configCommands := buildConfigCommands(deps)
+	osCommand := buildOSCommand(deps)
+
+	return NewFileCommands(deps.common, deps.cmd, configCommands, osCommand)
+}
--- a/pkg/commands/git_commands/file.go
+++ b/pkg/commands/git_commands/file.go
@@ -0,0 +1,80 @@
+package git_commands
+
+import (
+	"io/ioutil"
+	"strconv"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+type FileCommands struct {
+	*common.Common
+
+	cmd    oscommands.ICmdObjBuilder
+	config *ConfigCommands
+	os     FileOSCommand
+}
+
+type FileOSCommand interface {
+	Getenv(string) string
+}
+
+func NewFileCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	config *ConfigCommands,
+	osCommand FileOSCommand,
+) *FileCommands {
+	return &FileCommands{
+		Common: common,
+		cmd:    cmd,
+		config: config,
+		os:     osCommand,
+	}
+}
+
+// Cat obtains the content of a file
+func (self *FileCommands) Cat(fileName string) (string, error) {
+	buf, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return "", nil
+	}
+	return string(buf), nil
+}
+
+func (self *FileCommands) GetEditCmdStr(filename string, lineNumber int) (string, error) {
+	editor := self.UserConfig.OS.EditCommand
+
+	if editor == "" {
+		editor = self.config.GetCoreEditor()
+	}
+	if editor == "" {
+		editor = self.os.Getenv("GIT_EDITOR")
+	}
+	if editor == "" {
+		editor = self.os.Getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = self.os.Getenv("EDITOR")
+	}
+	if editor == "" {
+		if err := self.cmd.New("which vi").DontLog().Run(); err == nil {
+			editor = "vi"
+		}
+	}
+	if editor == "" {
+		return "", errors.New("No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
+	}
+
+	templateValues := map[string]string{
+		"editor":   editor,
+		"filename": self.cmd.Quote(filename),
+		"line":     strconv.Itoa(lineNumber),
+	}
+
+	editCmdTemplate := self.UserConfig.OS.EditCommandTemplate
+	return utils.ResolvePlaceholderString(editCmdTemplate, templateValues), nil
+}
--- a/pkg/commands/git_commands/file_test.go
+++ b/pkg/commands/git_commands/file_test.go
@@ -0,0 +1,163 @@
+package git_commands
+
+import (
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEditFileCmdStr(t *testing.T) {
+	type scenario struct {
+		filename                  string
+		configEditCommand         string
+		configEditCommandTemplate string
+		runner                    *oscommands.FakeCmdObjRunner
+		getenv                    func(string) string
+		gitConfigMockResponses    map[string]string
+		test                      func(string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			filename:                  "test",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`which vi`, "", errors.New("error")),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.EqualError(t, err, "No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
+			},
+		},
+		{
+			filename:                  "test",
+			configEditCommand:         "nano",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner:                    oscommands.NewFakeRunner(t),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `nano "test"`, cmdStr)
+			},
+		},
+		{
+			filename:                  "test",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner:                    oscommands.NewFakeRunner(t),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: map[string]string{"core.editor": "nano"},
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `nano "test"`, cmdStr)
+			},
+		},
+		{
+			filename:                  "test",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner:                    oscommands.NewFakeRunner(t),
+			getenv: func(env string) string {
+				if env == "VISUAL" {
+					return "nano"
+				}
+
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			filename:                  "test",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner:                    oscommands.NewFakeRunner(t),
+			getenv: func(env string) string {
+				if env == "EDITOR" {
+					return "emacs"
+				}
+
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `emacs "test"`, cmdStr)
+			},
+		},
+		{
+			filename:                  "test",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`which vi`, "/usr/bin/vi", nil),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `vi "test"`, cmdStr)
+			},
+		},
+		{
+			filename:                  "file/with space",
+			configEditCommand:         "",
+			configEditCommandTemplate: "{{editor}} {{filename}}",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`which vi`, "/usr/bin/vi", nil),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `vi "file/with space"`, cmdStr)
+			},
+		},
+		{
+			filename:                  "open file/at line",
+			configEditCommand:         "vim",
+			configEditCommandTemplate: "{{editor}} +{{line}} {{filename}}",
+			runner:                    oscommands.NewFakeRunner(t),
+			getenv: func(env string) string {
+				return ""
+			},
+			gitConfigMockResponses: nil,
+			test: func(cmdStr string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, `vim +1 "open file/at line"`, cmdStr)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		userConfig := config.GetDefaultConfig()
+		userConfig.OS.EditCommand = s.configEditCommand
+		userConfig.OS.EditCommandTemplate = s.configEditCommandTemplate
+
+		instance := buildFileCommands(commonDeps{
+			runner:     s.runner,
+			userConfig: userConfig,
+			gitConfig:  git_config.NewFakeGitConfig(s.gitConfigMockResponses),
+			getenv:     s.getenv,
+		})
+
+		s.test(instance.GetEditCmdStr(s.filename, 1))
+		s.runner.CheckForMissingCalls()
+	}
+}
--- a/pkg/commands/git_commands/flow.go
+++ b/pkg/commands/git_commands/flow.go
@@ -0,0 +1,64 @@
+package git_commands
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type FlowCommands struct {
+	*common.Common
+
+	config *ConfigCommands
+	cmd    oscommands.ICmdObjBuilder
+}
+
+func NewFlowCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	config *ConfigCommands,
+) *FlowCommands {
+	return &FlowCommands{
+		Common: common,
+		cmd:    cmd,
+		config: config,
+	}
+}
+
+func (self *FlowCommands) GitFlowEnabled() bool {
+	return self.config.GetGitFlowPrefixes() != ""
+}
+
+func (self *FlowCommands) FinishCmdObj(branchName string) (oscommands.ICmdObj, error) {
+	prefixes := self.config.GetGitFlowPrefixes()
+
+	// need to find out what kind of branch this is
+	prefix := strings.SplitAfterN(branchName, "/", 2)[0]
+	suffix := strings.Replace(branchName, prefix, "", 1)
+
+	branchType := ""
+	for _, line := range strings.Split(strings.TrimSpace(prefixes), "\n") {
+		if strings.HasPrefix(line, "gitflow.prefix.") && strings.HasSuffix(line, prefix) {
+			regex := regexp.MustCompile("gitflow.prefix.([^ ]*) .*")
+			matches := regex.FindAllStringSubmatch(line, 1)
+
+			if len(matches) > 0 && len(matches[0]) > 1 {
+				branchType = matches[0][1]
+				break
+			}
+		}
+	}
+
+	if branchType == "" {
+		return nil, errors.New(self.Tr.NotAGitFlowBranch)
+	}
+
+	return self.cmd.New("git flow " + branchType + " finish " + suffix), nil
+}
+
+func (self *FlowCommands) StartCmdObj(branchType string, name string) oscommands.ICmdObj {
+	return self.cmd.New("git flow " + branchType + " start " + name)
+}
--- a/pkg/commands/git_commands/patch.go
+++ b/pkg/commands/git_commands/patch.go
@@ -0,0 +1,262 @@
+package git_commands
+
+import (
+	"fmt"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/commands/patch"
+	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type PatchCommands struct {
+	*common.Common
+
+	cmd          oscommands.ICmdObjBuilder
+	rebase       *RebaseCommands
+	commit       *CommitCommands
+	config       *ConfigCommands
+	stash        *StashCommands
+	status       *StatusCommands
+	PatchManager *patch.PatchManager
+}
+
+func NewPatchCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	rebaseCommands *RebaseCommands,
+	commitCommands *CommitCommands,
+	configCommands *ConfigCommands,
+	statusCommands *StatusCommands,
+	patchManager *patch.PatchManager,
+) *PatchCommands {
+	return &PatchCommands{
+		Common:       common,
+		cmd:          cmd,
+		rebase:       rebaseCommands,
+		commit:       commitCommands,
+		config:       configCommands,
+		status:       statusCommands,
+		PatchManager: patchManager,
+	}
+}
+
+// DeletePatchesFromCommit applies a patch in reverse for a commit
+func (self *PatchCommands) DeletePatchesFromCommit(commits []*models.Commit, commitIndex int) error {
+	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
+		return err
+	}
+
+	// apply each patch in reverse
+	if err := self.PatchManager.ApplyPatches(true); err != nil {
+		if err := self.rebase.AbortRebase(); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// time to amend the selected commit
+	if err := self.commit.AmendHead(); err != nil {
+		return err
+	}
+
+	self.rebase.onSuccessfulContinue = func() error {
+		self.PatchManager.Reset()
+		return nil
+	}
+
+	// continue
+	return self.rebase.ContinueRebase()
+}
+
+func (self *PatchCommands) MovePatchToSelectedCommit(commits []*models.Commit, sourceCommitIdx int, destinationCommitIdx int) error {
+	if sourceCommitIdx < destinationCommitIdx {
+		if err := self.rebase.BeginInteractiveRebaseForCommit(commits, destinationCommitIdx); err != nil {
+			return err
+		}
+
+		// apply each patch forward
+		if err := self.PatchManager.ApplyPatches(false); err != nil {
+			if err := self.rebase.AbortRebase(); err != nil {
+				return err
+			}
+			return err
+		}
+
+		// amend the destination commit
+		if err := self.commit.AmendHead(); err != nil {
+			return err
+		}
+
+		self.rebase.onSuccessfulContinue = func() error {
+			self.PatchManager.Reset()
+			return nil
+		}
+
+		// continue
+		return self.rebase.ContinueRebase()
+	}
+
+	if len(commits)-1 < sourceCommitIdx {
+		return errors.New("index outside of range of commits")
+	}
+
+	// we can make this GPG thing possible it just means we need to do this in two parts:
+	// one where we handle the possibility of a credential request, and the other
+	// where we continue the rebase
+	if self.config.UsingGpg() {
+		return errors.New(self.Tr.DisabledForGPG)
+	}
+
+	baseIndex := sourceCommitIdx + 1
+	todo := ""
+	for i, commit := range commits[0:baseIndex] {
+		a := "pick"
+		if i == sourceCommitIdx || i == destinationCommitIdx {
+			a = "edit"
+		}
+		todo = a + " " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	err := self.rebase.PrepareInteractiveRebaseCommand(commits[baseIndex].Sha, todo, true).Run()
+	if err != nil {
+		return err
+	}
+
+	// apply each patch in reverse
+	if err := self.PatchManager.ApplyPatches(true); err != nil {
+		if err := self.rebase.AbortRebase(); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// amend the source commit
+	if err := self.commit.AmendHead(); err != nil {
+		return err
+	}
+
+	if self.rebase.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	self.rebase.onSuccessfulContinue = func() error {
+		// now we should be up to the destination, so let's apply forward these patches to that.
+		// ideally we would ensure we're on the right commit but I'm not sure if that check is necessary
+		if err := self.PatchManager.ApplyPatches(false); err != nil {
+			if err := self.rebase.AbortRebase(); err != nil {
+				return err
+			}
+			return err
+		}
+
+		// amend the destination commit
+		if err := self.commit.AmendHead(); err != nil {
+			return err
+		}
+
+		self.rebase.onSuccessfulContinue = func() error {
+			self.PatchManager.Reset()
+			return nil
+		}
+
+		return self.rebase.ContinueRebase()
+	}
+
+	return self.rebase.ContinueRebase()
+}
+
+func (self *PatchCommands) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, stash bool) error {
+	if stash {
+		if err := self.stash.Save(self.Tr.StashPrefix + commits[commitIdx].Sha); err != nil {
+			return err
+		}
+	}
+
+	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
+		return err
+	}
+
+	if err := self.PatchManager.ApplyPatches(true); err != nil {
+		if self.status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
+			if err := self.rebase.AbortRebase(); err != nil {
+				return err
+			}
+		}
+		return err
+	}
+
+	// amend the commit
+	if err := self.commit.AmendHead(); err != nil {
+		return err
+	}
+
+	if self.rebase.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	self.rebase.onSuccessfulContinue = func() error {
+		// add patches to index
+		if err := self.PatchManager.ApplyPatches(false); err != nil {
+			if self.status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
+				if err := self.rebase.AbortRebase(); err != nil {
+					return err
+				}
+			}
+			return err
+		}
+
+		if stash {
+			if err := self.stash.Apply(0); err != nil {
+				return err
+			}
+		}
+
+		self.PatchManager.Reset()
+		return nil
+	}
+
+	return self.rebase.ContinueRebase()
+}
+
+func (self *PatchCommands) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx int) error {
+	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
+		return err
+	}
+
+	if err := self.PatchManager.ApplyPatches(true); err != nil {
+		if err := self.rebase.AbortRebase(); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// amend the commit
+	if err := self.commit.AmendHead(); err != nil {
+		return err
+	}
+
+	// add patches to index
+	if err := self.PatchManager.ApplyPatches(false); err != nil {
+		if err := self.rebase.AbortRebase(); err != nil {
+			return err
+		}
+		return err
+	}
+
+	head_message, _ := self.commit.GetHeadCommitMessage()
+	new_message := fmt.Sprintf("Split from \"%s\"", head_message)
+	err := self.commit.CommitCmdObj(new_message).Run()
+	if err != nil {
+		return err
+	}
+
+	if self.rebase.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	self.PatchManager.Reset()
+	return self.rebase.ContinueRebase()
+}
--- a/pkg/commands/git_commands/rebase.go
+++ b/pkg/commands/git_commands/rebase.go
@@ -0,0 +1,359 @@
+package git_commands
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type RebaseCommands struct {
+	*common.Common
+
+	cmd       oscommands.ICmdObjBuilder
+	osCommand *oscommands.OSCommand
+
+	commit               *CommitCommands
+	workingTree          *WorkingTreeCommands
+	config               *ConfigCommands
+	dotGitDir            string
+	onSuccessfulContinue func() error
+}
+
+func NewRebaseCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	osCommand *oscommands.OSCommand,
+	commitCommands *CommitCommands,
+	workingTreeCommands *WorkingTreeCommands,
+	configCommands *ConfigCommands,
+	dotGitDir string,
+) *RebaseCommands {
+	return &RebaseCommands{
+		Common:      common,
+		cmd:         cmd,
+		osCommand:   osCommand,
+		commit:      commitCommands,
+		workingTree: workingTreeCommands,
+		config:      configCommands,
+		dotGitDir:   dotGitDir,
+	}
+}
+
+func (self *RebaseCommands) RewordCommit(commits []*models.Commit, index int, message string) error {
+	if index == 0 {
+		// we've selected the top commit so no rebase is required
+		return self.commit.RewordLastCommit(message)
+	}
+
+	err := self.BeginInteractiveRebaseForCommit(commits, index)
+	if err != nil {
+		return err
+	}
+
+	// now the selected commit should be our head so we'll amend it with the new message
+	err = self.commit.RewordLastCommit(message)
+	if err != nil {
+		return err
+	}
+
+	return self.ContinueRebase()
+}
+
+func (self *RebaseCommands) RewordCommitInEditor(commits []*models.Commit, index int) (oscommands.ICmdObj, error) {
+	todo, sha, err := self.GenerateGenericRebaseTodo(commits, index, "reword")
+	if err != nil {
+		return nil, err
+	}
+
+	return self.PrepareInteractiveRebaseCommand(sha, todo, false), nil
+}
+
+func (self *RebaseCommands) MoveCommitDown(commits []*models.Commit, index int) error {
+	// we must ensure that we have at least two commits after the selected one
+	if len(commits) <= index+2 {
+		// assuming they aren't picking the bottom commit
+		return errors.New(self.Tr.NoRoom)
+	}
+
+	todo := ""
+	orderedCommits := append(commits[0:index], commits[index+1], commits[index])
+	for _, commit := range orderedCommits {
+		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	return self.PrepareInteractiveRebaseCommand(commits[index+2].Sha, todo, true).Run()
+}
+
+func (self *RebaseCommands) InteractiveRebase(commits []*models.Commit, index int, action string) error {
+	todo, sha, err := self.GenerateGenericRebaseTodo(commits, index, action)
+	if err != nil {
+		return err
+	}
+
+	return self.PrepareInteractiveRebaseCommand(sha, todo, true).Run()
+}
+
+// PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase
+// we tell git to run lazygit to edit the todo list, and we pass the client
+// lazygit a todo string to write to the todo file
+func (self *RebaseCommands) PrepareInteractiveRebaseCommand(baseSha string, todo string, overrideEditor bool) oscommands.ICmdObj {
+	ex := oscommands.GetLazygitPath()
+
+	debug := "FALSE"
+	if self.Debug {
+		debug = "TRUE"
+	}
+
+	cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty %s", baseSha)
+	self.Log.WithField("command", cmdStr).Info("RunCommand")
+
+	cmdObj := self.cmd.New(cmdStr)
+
+	gitSequenceEditor := ex
+	if todo == "" {
+		gitSequenceEditor = "true"
+	} else {
+		self.osCommand.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
+	}
+
+	cmdObj.AddEnvVars(
+		"LAZYGIT_CLIENT_COMMAND=INTERACTIVE_REBASE",
+		"LAZYGIT_REBASE_TODO="+todo,
+		"DEBUG="+debug,
+		"LANG=en_US.UTF-8",   // Force using EN as language
+		"LC_ALL=en_US.UTF-8", // Force using EN as language
+		"GIT_SEQUENCE_EDITOR="+gitSequenceEditor,
+	)
+
+	if overrideEditor {
+		cmdObj.AddEnvVars("GIT_EDITOR=" + ex)
+	}
+
+	return cmdObj
+}
+
+func (self *RebaseCommands) GenerateGenericRebaseTodo(commits []*models.Commit, actionIndex int, action string) (string, string, error) {
+	baseIndex := actionIndex + 1
+
+	if len(commits) <= baseIndex {
+		return "", "", errors.New(self.Tr.CannotRebaseOntoFirstCommit)
+	}
+
+	if action == "squash" || action == "fixup" {
+		baseIndex++
+
+		if len(commits) <= baseIndex {
+			return "", "", errors.New(self.Tr.CannotSquashOntoSecondCommit)
+		}
+	}
+
+	todo := ""
+	for i, commit := range commits[0:baseIndex] {
+		var commitAction string
+		if i == actionIndex {
+			commitAction = action
+		} else if commit.IsMerge() {
+			// your typical interactive rebase will actually drop merge commits by default. Damn git CLI, you scary!
+			// doing this means we don't need to worry about rebasing over merges which always causes problems.
+			// you typically shouldn't be doing rebases that pass over merge commits anyway.
+			commitAction = "drop"
+		} else {
+			commitAction = "pick"
+		}
+		todo = commitAction + " " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	return todo, commits[baseIndex].Sha, nil
+}
+
+// AmendTo amends the given commit with whatever files are staged
+func (self *RebaseCommands) AmendTo(sha string) error {
+	if err := self.commit.CreateFixupCommit(sha); err != nil {
+		return err
+	}
+
+	return self.SquashAllAboveFixupCommits(sha)
+}
+
+// EditRebaseTodo sets the action at a given index in the git-rebase-todo file
+func (self *RebaseCommands) EditRebaseTodo(index int, action string) error {
+	fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
+	bytes, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	content := strings.Split(string(bytes), "\n")
+	commitCount := self.getTodoCommitCount(content)
+
+	// we have the most recent commit at the bottom whereas the todo file has
+	// it at the bottom, so we need to subtract our index from the commit count
+	contentIndex := commitCount - 1 - index
+	splitLine := strings.Split(content[contentIndex], " ")
+	content[contentIndex] = action + " " + strings.Join(splitLine[1:], " ")
+	result := strings.Join(content, "\n")
+
+	return ioutil.WriteFile(fileName, []byte(result), 0644)
+}
+
+func (self *RebaseCommands) getTodoCommitCount(content []string) int {
+	// count lines that are not blank and are not comments
+	commitCount := 0
+	for _, line := range content {
+		if line != "" && !strings.HasPrefix(line, "#") {
+			commitCount++
+		}
+	}
+	return commitCount
+}
+
+// MoveTodoDown moves a rebase todo item down by one position
+func (self *RebaseCommands) MoveTodoDown(index int) error {
+	fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
+	bytes, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	content := strings.Split(string(bytes), "\n")
+	commitCount := self.getTodoCommitCount(content)
+	contentIndex := commitCount - 1 - index
+
+	rearrangedContent := append(content[0:contentIndex-1], content[contentIndex], content[contentIndex-1])
+	rearrangedContent = append(rearrangedContent, content[contentIndex+1:]...)
+	result := strings.Join(rearrangedContent, "\n")
+
+	return ioutil.WriteFile(fileName, []byte(result), 0644)
+}
+
+// SquashAllAboveFixupCommits squashes all fixup! commits above the given one
+func (self *RebaseCommands) SquashAllAboveFixupCommits(sha string) error {
+	return self.runSkipEditorCommand(
+		self.cmd.New(
+			fmt.Sprintf(
+				"git rebase --interactive --autostash --autosquash %s^",
+				sha,
+			),
+		),
+	)
+}
+
+// BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current
+// commit and pick all others. After this you'll want to call `self.ContinueRebase()
+func (self *RebaseCommands) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error {
+	if len(commits)-1 < commitIndex {
+		return errors.New("index outside of range of commits")
+	}
+
+	// we can make this GPG thing possible it just means we need to do this in two parts:
+	// one where we handle the possibility of a credential request, and the other
+	// where we continue the rebase
+	if self.config.UsingGpg() {
+		return errors.New(self.Tr.DisabledForGPG)
+	}
+
+	todo, sha, err := self.GenerateGenericRebaseTodo(commits, commitIndex, "edit")
+	if err != nil {
+		return err
+	}
+
+	return self.PrepareInteractiveRebaseCommand(sha, todo, true).Run()
+}
+
+// RebaseBranch interactive rebases onto a branch
+func (self *RebaseCommands) RebaseBranch(branchName string) error {
+	return self.PrepareInteractiveRebaseCommand(branchName, "", false).Run()
+}
+
+func (self *RebaseCommands) GenericMergeOrRebaseActionCmdObj(commandType string, command string) oscommands.ICmdObj {
+	return self.cmd.New("git " + commandType + " --" + command)
+}
+
+func (self *RebaseCommands) ContinueRebase() error {
+	return self.GenericMergeOrRebaseAction("rebase", "continue")
+}
+
+func (self *RebaseCommands) AbortRebase() error {
+	return self.GenericMergeOrRebaseAction("rebase", "abort")
+}
+
+// GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
+// By default we skip the editor in the case where a commit will be made
+func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, command string) error {
+	err := self.runSkipEditorCommand(self.GenericMergeOrRebaseActionCmdObj(commandType, command))
+	if err != nil {
+		if !strings.Contains(err.Error(), "no rebase in progress") {
+			return err
+		}
+		self.Log.Warn(err)
+	}
+
+	// sometimes we need to do a sequence of things in a rebase but the user needs to
+	// fix merge conflicts along the way. When this happens we queue up the next step
+	// so that after the next successful rebase continue we can continue from where we left off
+	if commandType == "rebase" && command == "continue" && self.onSuccessfulContinue != nil {
+		f := self.onSuccessfulContinue
+		self.onSuccessfulContinue = nil
+		return f()
+	}
+	if command == "abort" {
+		self.onSuccessfulContinue = nil
+	}
+	return nil
+}
+
+func (self *RebaseCommands) runSkipEditorCommand(cmdObj oscommands.ICmdObj) error {
+	lazyGitPath := oscommands.GetLazygitPath()
+	return cmdObj.
+		AddEnvVars(
+			"LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY",
+			"GIT_EDITOR="+lazyGitPath,
+			"EDITOR="+lazyGitPath,
+			"VISUAL="+lazyGitPath,
+		).
+		Run()
+}
+
+// DiscardOldFileChanges discards changes to a file from an old commit
+func (self *RebaseCommands) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error {
+	if err := self.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
+		return err
+	}
+
+	// check if file exists in previous commit (this command returns an error if the file doesn't exist)
+	if err := self.cmd.New("git cat-file -e HEAD^:" + self.cmd.Quote(fileName)).Run(); err != nil {
+		if err := self.osCommand.Remove(fileName); err != nil {
+			return err
+		}
+		if err := self.workingTree.StageFile(fileName); err != nil {
+			return err
+		}
+	} else if err := self.workingTree.CheckoutFile("HEAD^", fileName); err != nil {
+		return err
+	}
+
+	// amend the commit
+	err := self.commit.AmendHead()
+	if err != nil {
+		return err
+	}
+
+	// continue
+	return self.ContinueRebase()
+}
+
+// CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
+func (self *RebaseCommands) CherryPickCommits(commits []*models.Commit) error {
+	todo := ""
+	for _, commit := range commits {
+		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	return self.PrepareInteractiveRebaseCommand("HEAD", todo, false).Run()
+}
--- a/pkg/commands/git_commands/rebase_test.go
+++ b/pkg/commands/git_commands/rebase_test.go
@@ -0,0 +1,151 @@
+package git_commands
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRebaseRebaseBranch(t *testing.T) {
+	type scenario struct {
+		testName string
+		arg      string
+		runner   *oscommands.FakeCmdObjRunner
+		test     func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			testName: "successful rebase",
+			arg:      "master",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git rebase --interactive --autostash --keep-empty master`, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			testName: "unsuccessful rebase",
+			arg:      "master",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git rebase --interactive --autostash --keep-empty master`, "", errors.New("error")),
+			test: func(err error) {
+				assert.Error(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			instance := buildRebaseCommands(commonDeps{runner: s.runner})
+			s.test(instance.RebaseBranch(s.arg))
+		})
+	}
+}
+
+// TestRebaseSkipEditorCommand confirms that SkipEditorCommand injects
+// environment variables that suppress an interactive editor
+func TestRebaseSkipEditorCommand(t *testing.T) {
+	commandStr := "git blah"
+	runner := oscommands.NewFakeRunner(t).ExpectFunc(func(cmdObj oscommands.ICmdObj) (string, error) {
+		assert.Equal(t, commandStr, cmdObj.ToString())
+		envVars := cmdObj.GetEnvVars()
+		for _, regexStr := range []string{
+			`^VISUAL=.*$`,
+			`^EDITOR=.*$`,
+			`^GIT_EDITOR=.*$`,
+			"^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$",
+		} {
+			regexStr := regexStr
+			foundMatch := utils.IncludesStringFunc(envVars, func(envVar string) bool {
+				return regexp.MustCompile(regexStr).MatchString(envVar)
+			})
+			if !foundMatch {
+				t.Errorf("expected environment variable %s to be set", regexStr)
+			}
+		}
+		return "", nil
+	})
+	instance := buildRebaseCommands(commonDeps{runner: runner})
+	err := instance.runSkipEditorCommand(instance.cmd.New(commandStr))
+	assert.NoError(t, err)
+	runner.CheckForMissingCalls()
+}
+
+func TestRebaseDiscardOldFileChanges(t *testing.T) {
+	type scenario struct {
+		testName               string
+		gitConfigMockResponses map[string]string
+		commits                []*models.Commit
+		commitIndex            int
+		fileName               string
+		runner                 *oscommands.FakeCmdObjRunner
+		test                   func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			testName:               "returns error when index outside of range of commits",
+			gitConfigMockResponses: nil,
+			commits:                []*models.Commit{},
+			commitIndex:            0,
+			fileName:               "test999.txt",
+			runner:                 oscommands.NewFakeRunner(t),
+			test: func(err error) {
+				assert.Error(t, err)
+			},
+		},
+		{
+			testName:               "returns error when using gpg",
+			gitConfigMockResponses: map[string]string{"commit.gpgsign": "true"},
+			commits:                []*models.Commit{{Name: "commit", Sha: "123456"}},
+			commitIndex:            0,
+			fileName:               "test999.txt",
+			runner:                 oscommands.NewFakeRunner(t),
+			test: func(err error) {
+				assert.Error(t, err)
+			},
+		},
+		{
+			testName:               "checks out file if it already existed",
+			gitConfigMockResponses: nil,
+			commits: []*models.Commit{
+				{Name: "commit", Sha: "123456"},
+				{Name: "commit2", Sha: "abcdef"},
+			},
+			commitIndex: 0,
+			fileName:    "test999.txt",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git rebase --interactive --autostash --keep-empty abcdef`, "", nil).
+				Expect(`git cat-file -e HEAD^:"test999.txt"`, "", nil).
+				Expect(`git checkout HEAD^ -- "test999.txt"`, "", nil).
+				Expect(`git commit --amend --no-edit --allow-empty`, "", nil).
+				Expect(`git rebase --continue`, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		// test for when the file was created within the commit requires a refactor to support proper mocks
+		// currently we'd need to mock out the os.Remove function and that's gonna introduce tech debt
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			instance := buildRebaseCommands(commonDeps{
+				runner:    s.runner,
+				gitConfig: git_config.NewFakeGitConfig(s.gitConfigMockResponses),
+			})
+
+			s.test(instance.DiscardOldFileChanges(s.commits, s.commitIndex, s.fileName))
+			s.runner.CheckForMissingCalls()
+		})
+	}
+}
--- a/pkg/commands/git_commands/remote.go
+++ b/pkg/commands/git_commands/remote.go
@@ -0,0 +1,67 @@
+package git_commands
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type RemoteCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewRemoteCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *RemoteCommands {
+	return &RemoteCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+func (self *RemoteCommands) AddRemote(name string, url string) error {
+	return self.cmd.
+		New(fmt.Sprintf("git remote add %s %s", self.cmd.Quote(name), self.cmd.Quote(url))).
+		Run()
+}
+
+func (self *RemoteCommands) RemoveRemote(name string) error {
+	return self.cmd.
+		New(fmt.Sprintf("git remote remove %s", self.cmd.Quote(name))).
+		Run()
+}
+
+func (self *RemoteCommands) RenameRemote(oldRemoteName string, newRemoteName string) error {
+	return self.cmd.
+		New(fmt.Sprintf("git remote rename %s %s", self.cmd.Quote(oldRemoteName), self.cmd.Quote(newRemoteName))).
+		Run()
+}
+
+func (self *RemoteCommands) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
+	return self.cmd.
+		New(fmt.Sprintf("git remote set-url %s %s", self.cmd.Quote(remoteName), self.cmd.Quote(updatedUrl))).
+		Run()
+}
+
+func (self *RemoteCommands) DeleteRemoteBranch(remoteName string, branchName string) error {
+	command := fmt.Sprintf("git push %s --delete %s", self.cmd.Quote(remoteName), self.cmd.Quote(branchName))
+	return self.cmd.New(command).PromptOnCredentialRequest().Run()
+}
+
+// CheckRemoteBranchExists Returns remote branch
+func (self *RemoteCommands) CheckRemoteBranchExists(branchName string) bool {
+	_, err := self.cmd.
+		New(
+			fmt.Sprintf("git show-ref --verify -- refs/remotes/origin/%s",
+				self.cmd.Quote(branchName),
+			),
+		).
+		DontLog().
+		RunWithOutput()
+
+	return err == nil
+}
--- a/pkg/commands/git_commands/stash.go
+++ b/pkg/commands/git_commands/stash.go
@@ -0,0 +1,99 @@
+package git_commands
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type StashCommands struct {
+	*common.Common
+
+	cmd         oscommands.ICmdObjBuilder
+	fileLoader  *loaders.FileLoader
+	osCommand   *oscommands.OSCommand
+	workingTree *WorkingTreeCommands
+}
+
+func NewStashCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	osCommand *oscommands.OSCommand,
+	fileLoader *loaders.FileLoader,
+	workingTree *WorkingTreeCommands,
+) *StashCommands {
+	return &StashCommands{
+		Common:      common,
+		cmd:         cmd,
+		fileLoader:  fileLoader,
+		osCommand:   osCommand,
+		workingTree: workingTree,
+	}
+}
+
+func (self *StashCommands) Drop(index int) error {
+	return self.cmd.New(fmt.Sprintf("git stash drop stash@{%d}", index)).Run()
+}
+
+func (self *StashCommands) Pop(index int) error {
+	return self.cmd.New(fmt.Sprintf("git stash pop stash@{%d}", index)).Run()
+}
+
+func (self *StashCommands) Apply(index int) error {
+	return self.cmd.New(fmt.Sprintf("git stash apply stash@{%d}", index)).Run()
+}
+
+// Save save stash
+// TODO: before calling this, check if there is anything to save
+func (self *StashCommands) Save(message string) error {
+	return self.cmd.New("git stash save " + self.cmd.Quote(message)).Run()
+}
+
+func (self *StashCommands) ShowStashEntryCmdObj(index int) oscommands.ICmdObj {
+	cmdStr := fmt.Sprintf("git stash show -p --stat --color=%s --unified=%d stash@{%d}", self.UserConfig.Git.Paging.ColorArg, self.UserConfig.Git.DiffContextSize, index)
+
+	return self.cmd.New(cmdStr).DontLog()
+}
+
+// SaveStagedChanges stashes only the currently staged changes. This takes a few steps
+// shoutouts to Joe on https://stackoverflow.com/questions/14759748/stashing-only-staged-changes-in-git-is-it-possible
+func (self *StashCommands) SaveStagedChanges(message string) error {
+	// wrap in 'writing', which uses a mutex
+	if err := self.cmd.New("git stash --keep-index").Run(); err != nil {
+		return err
+	}
+
+	if err := self.Save(message); err != nil {
+		return err
+	}
+
+	if err := self.cmd.New("git stash apply stash@{1}").Run(); err != nil {
+		return err
+	}
+
+	if err := self.osCommand.PipeCommands("git stash show -p", "git apply -R"); err != nil {
+		return err
+	}
+
+	if err := self.cmd.New("git stash drop stash@{1}").Run(); err != nil {
+		return err
+	}
+
+	// if you had staged an untracked file, that will now appear as 'AD' in git status
+	// meaning it's deleted in your working tree but added in your index. Given that it's
+	// now safely stashed, we need to remove it.
+	files := self.fileLoader.
+		GetStatusFiles(loaders.GetStatusFileOptions{})
+
+	for _, file := range files {
+		if file.ShortStatus == "AD" {
+			if err := self.workingTree.UnStageFile(file.Names(), false); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
--- a/pkg/commands/git_commands/stash_test.go
+++ b/pkg/commands/git_commands/stash_test.go
@@ -0,0 +1,81 @@
+package git_commands
+
+import (
+	"testing"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStashDrop(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"stash", "drop", "stash@{1}"}, "", nil)
+	instance := buildStashCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.Drop(1))
+	runner.CheckForMissingCalls()
+}
+
+func TestStashApply(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"stash", "apply", "stash@{1}"}, "", nil)
+	instance := buildStashCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.Apply(1))
+	runner.CheckForMissingCalls()
+}
+
+func TestStashPop(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"stash", "pop", "stash@{1}"}, "", nil)
+	instance := buildStashCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.Pop(1))
+	runner.CheckForMissingCalls()
+}
+
+func TestStashSave(t *testing.T) {
+	runner := oscommands.NewFakeRunner(t).
+		ExpectGitArgs([]string{"stash", "save", "A stash message"}, "", nil)
+	instance := buildStashCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.Save("A stash message"))
+	runner.CheckForMissingCalls()
+}
+
+func TestStashStashEntryCmdObj(t *testing.T) {
+	type scenario struct {
+		testName    string
+		index       int
+		contextSize int
+		expected    string
+	}
+
+	scenarios := []scenario{
+		{
+			testName:    "Default case",
+			index:       5,
+			contextSize: 3,
+			expected:    "git stash show -p --stat --color=always --unified=3 stash@{5}",
+		},
+		{
+			testName:    "Show diff with custom context size",
+			index:       5,
+			contextSize: 77,
+			expected:    "git stash show -p --stat --color=always --unified=77 stash@{5}",
+		},
+	}
+
+	for _, s := range scenarios {
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			userConfig := config.GetDefaultConfig()
+			userConfig.Git.DiffContextSize = s.contextSize
+			instance := buildStashCommands(commonDeps{userConfig: userConfig})
+
+			cmdStr := instance.ShowStashEntryCmdObj(s.index).ToString()
+			assert.Equal(t, s.expected, cmdStr)
+		})
+	}
+}
--- a/pkg/commands/git_commands/status.go
+++ b/pkg/commands/git_commands/status.go
@@ -0,0 +1,72 @@
+package git_commands
+
+import (
+	"path/filepath"
+
+	gogit "github.com/jesseduffield/go-git/v5"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type StatusCommands struct {
+	*common.Common
+	osCommand *oscommands.OSCommand
+	repo      *gogit.Repository
+	dotGitDir string
+}
+
+func NewStatusCommands(
+	common *common.Common,
+	osCommand *oscommands.OSCommand,
+	repo *gogit.Repository,
+	dotGitDir string,
+) *StatusCommands {
+	return &StatusCommands{
+		Common:    common,
+		osCommand: osCommand,
+		repo:      repo,
+		dotGitDir: dotGitDir,
+	}
+}
+
+// RebaseMode returns "" for non-rebase mode, "normal" for normal rebase
+// and "interactive" for interactive rebase
+func (self *StatusCommands) RebaseMode() (enums.RebaseMode, error) {
+	exists, err := self.osCommand.FileExists(filepath.Join(self.dotGitDir, "rebase-apply"))
+	if err != nil {
+		return enums.REBASE_MODE_NONE, err
+	}
+	if exists {
+		return enums.REBASE_MODE_NORMAL, nil
+	}
+	exists, err = self.osCommand.FileExists(filepath.Join(self.dotGitDir, "rebase-merge"))
+	if exists {
+		return enums.REBASE_MODE_INTERACTIVE, err
+	} else {
+		return enums.REBASE_MODE_NONE, err
+	}
+}
+
+func (self *StatusCommands) WorkingTreeState() enums.RebaseMode {
+	rebaseMode, _ := self.RebaseMode()
+	if rebaseMode != enums.REBASE_MODE_NONE {
+		return enums.REBASE_MODE_REBASING
+	}
+	merging, _ := self.IsInMergeState()
+	if merging {
+		return enums.REBASE_MODE_MERGING
+	}
+	return enums.REBASE_MODE_NONE
+}
+
+// IsInMergeState states whether we are still mid-merge
+func (self *StatusCommands) IsInMergeState() (bool, error) {
+	return self.osCommand.FileExists(filepath.Join(self.dotGitDir, "MERGE_HEAD"))
+}
+
+func (self *StatusCommands) IsBareRepo() bool {
+	// note: could use `git rev-parse --is-bare-repository` if we wanna drop go-git
+	_, err := self.repo.Worktree()
+	return err == gogit.ErrIsBareRepository
+}
--- a/pkg/commands/git_commands/submodule.go
+++ b/pkg/commands/git_commands/submodule.go
@@ -1,4 +1,4 @@
-package commands
+package git_commands

 import (
 	"bufio"
@@ -25,8 +25,8 @@ type SubmoduleCommands struct {
 	dotGitDir string
 }

-func NewSubmoduleCommands(common *common.Common, cmd oscommands.ICmdObjBuilder, dotGitDir string) SubmoduleCommands {
-	return SubmoduleCommands{
+func NewSubmoduleCommands(common *common.Common, cmd oscommands.ICmdObjBuilder, dotGitDir string) *SubmoduleCommands {
+	return &SubmoduleCommands{
 		Common:    common,
 		cmd:       cmd,
 		dotGitDir: dotGitDir,
--- a/pkg/commands/git_commands/sync.go
+++ b/pkg/commands/git_commands/sync.go
@@ -0,0 +1,129 @@
+package git_commands
+
+import (
+	"fmt"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type SyncCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewSyncCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+) *SyncCommands {
+	return &SyncCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+// Push pushes to a branch
+type PushOpts struct {
+	Force          bool
+	UpstreamRemote string
+	UpstreamBranch string
+	SetUpstream    bool
+}
+
+func (self *SyncCommands) PushCmdObj(opts PushOpts) (oscommands.ICmdObj, error) {
+	cmdStr := "git push"
+
+	if opts.Force {
+		cmdStr += " --force-with-lease"
+	}
+
+	if opts.SetUpstream {
+		cmdStr += " --set-upstream"
+	}
+
+	if opts.UpstreamRemote != "" {
+		cmdStr += " " + self.cmd.Quote(opts.UpstreamRemote)
+	}
+
+	if opts.UpstreamBranch != "" {
+		if opts.UpstreamRemote == "" {
+			return nil, errors.New(self.Tr.MustSpecifyOriginError)
+		}
+		cmdStr += " " + self.cmd.Quote(opts.UpstreamBranch)
+	}
+
+	cmdObj := self.cmd.New(cmdStr).PromptOnCredentialRequest()
+	return cmdObj, nil
+}
+
+func (self *SyncCommands) Push(opts PushOpts) error {
+	cmdObj, err := self.PushCmdObj(opts)
+	if err != nil {
+		return err
+	}
+
+	return cmdObj.Run()
+}
+
+type FetchOptions struct {
+	Background bool
+	RemoteName string
+	BranchName string
+}
+
+// Fetch fetch git repo
+func (self *SyncCommands) Fetch(opts FetchOptions) error {
+	cmdStr := "git fetch"
+
+	if opts.RemoteName != "" {
+		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.RemoteName))
+	}
+	if opts.BranchName != "" {
+		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.BranchName))
+	}
+
+	cmdObj := self.cmd.New(cmdStr)
+	if opts.Background {
+		cmdObj.DontLog().FailOnCredentialRequest()
+	} else {
+		cmdObj.PromptOnCredentialRequest()
+	}
+	return cmdObj.Run()
+}
+
+type PullOptions struct {
+	RemoteName      string
+	BranchName      string
+	FastForwardOnly bool
+}
+
+func (self *SyncCommands) Pull(opts PullOptions) error {
+	cmdStr := "git pull --no-edit"
+
+	if opts.FastForwardOnly {
+		cmdStr += " --ff-only"
+	}
+
+	if opts.RemoteName != "" {
+		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.RemoteName))
+	}
+	if opts.BranchName != "" {
+		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.BranchName))
+	}
+
+	// setting GIT_SEQUENCE_EDITOR to ':' as a way of skipping it, in case the user
+	// has 'pull.rebase = interactive' configured.
+	return self.cmd.New(cmdStr).AddEnvVars("GIT_SEQUENCE_EDITOR=:").PromptOnCredentialRequest().Run()
+}
+
+func (self *SyncCommands) FastForward(branchName string, remoteName string, remoteBranchName string) error {
+	cmdStr := fmt.Sprintf("git fetch %s %s:%s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName), self.cmd.Quote(branchName))
+	return self.cmd.New(cmdStr).PromptOnCredentialRequest().Run()
+}
+
+func (self *SyncCommands) FetchRemote(remoteName string) error {
+	cmdStr := fmt.Sprintf("git fetch %s", self.cmd.Quote(remoteName))
+	return self.cmd.New(cmdStr).PromptOnCredentialRequest().Run()
+}
--- a/pkg/commands/git_commands/sync_test.go
+++ b/pkg/commands/git_commands/sync_test.go
@@ -1,4 +1,4 @@
-package commands
+package git_commands

 import (
 	"testing"
@@ -7,7 +7,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )

-func TestGitCommandPush(t *testing.T) {
+func TestSyncPush(t *testing.T) {
 	type scenario struct {
 		testName string
 		opts     PushOpts
@@ -85,9 +85,10 @@ func TestGitCommandPush(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(oscommands.NewFakeRunner(t))
-			s.test(gitCmd.PushCmdObj(s.opts))
+			instance := buildSyncCommands(commonDeps{})
+			s.test(instance.PushCmdObj(s.opts))
 		})
 	}
 }
--- a/pkg/commands/git_commands/tag.go
+++ b/pkg/commands/git_commands/tag.go
@@ -0,0 +1,37 @@
+package git_commands
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+)
+
+type TagCommands struct {
+	*common.Common
+
+	cmd oscommands.ICmdObjBuilder
+}
+
+func NewTagCommands(common *common.Common, cmd oscommands.ICmdObjBuilder) *TagCommands {
+	return &TagCommands{
+		Common: common,
+		cmd:    cmd,
+	}
+}
+
+func (self *TagCommands) CreateLightweight(tagName string, commitSha string) error {
+	return self.cmd.New(fmt.Sprintf("git tag -- %s %s", self.cmd.Quote(tagName), commitSha)).Run()
+}
+
+func (self *TagCommands) CreateAnnotated(tagName, commitSha, msg string) error {
+	return self.cmd.New(fmt.Sprintf("git tag %s %s -m %s", tagName, commitSha, self.cmd.Quote(msg))).Run()
+}
+
+func (self *TagCommands) Delete(tagName string) error {
+	return self.cmd.New(fmt.Sprintf("git tag -d %s", self.cmd.Quote(tagName))).Run()
+}
+
+func (self *TagCommands) Push(remoteName string, tagName string) error {
+	return self.cmd.New(fmt.Sprintf("git push %s %s", self.cmd.Quote(remoteName), self.cmd.Quote(tagName))).PromptOnCredentialRequest().Run()
+}
--- a/pkg/commands/git_commands/working_tree.go
+++ b/pkg/commands/git_commands/working_tree.go
@@ -0,0 +1,356 @@
+package git_commands
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/common"
+	"github.com/jesseduffield/lazygit/pkg/gui/filetree"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+type WorkingTreeCommands struct {
+	*common.Common
+
+	cmd        oscommands.ICmdObjBuilder
+	os         WorkingTreeOSCommand
+	submodule  *SubmoduleCommands
+	fileLoader *loaders.FileLoader
+}
+
+type WorkingTreeOSCommand interface {
+	RemoveFile(string) error
+	CreateFileWithContent(string, string) error
+	AppendLineToFile(string, string) error
+}
+
+func NewWorkingTreeCommands(
+	common *common.Common,
+	cmd oscommands.ICmdObjBuilder,
+	submoduleCommands *SubmoduleCommands,
+	osCommand WorkingTreeOSCommand,
+	fileLoader *loaders.FileLoader,
+) *WorkingTreeCommands {
+	return &WorkingTreeCommands{
+		Common:     common,
+		cmd:        cmd,
+		os:         osCommand,
+		submodule:  submoduleCommands,
+		fileLoader: fileLoader,
+	}
+}
+
+func (self *WorkingTreeCommands) OpenMergeToolCmdObj() oscommands.ICmdObj {
+	return self.cmd.New("git mergetool")
+}
+
+func (self *WorkingTreeCommands) OpenMergeTool() error {
+	return self.OpenMergeToolCmdObj().Run()
+}
+
+// StageFile stages a file
+func (self *WorkingTreeCommands) StageFile(fileName string) error {
+	return self.cmd.New("git add -- " + self.cmd.Quote(fileName)).Run()
+}
+
+// StageAll stages all files
+func (self *WorkingTreeCommands) StageAll() error {
+	return self.cmd.New("git add -A").Run()
+}
+
+// UnstageAll unstages all files
+func (self *WorkingTreeCommands) UnstageAll() error {
+	return self.cmd.New("git reset").Run()
+}
+
+// UnStageFile unstages a file
+// we accept an array of filenames for the cases where a file has been renamed i.e.
+// we accept the current name and the previous name
+func (self *WorkingTreeCommands) UnStageFile(fileNames []string, reset bool) error {
+	command := "git rm --cached --force -- %s"
+	if reset {
+		command = "git reset HEAD -- %s"
+	}
+
+	for _, name := range fileNames {
+		err := self.cmd.New(fmt.Sprintf(command, self.cmd.Quote(name))).Run()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (self *WorkingTreeCommands) BeforeAndAfterFileForRename(file *models.File) (*models.File, *models.File, error) {
+	if !file.IsRename() {
+		return nil, nil, errors.New("Expected renamed file")
+	}
+
+	// we've got a file that represents a rename from one file to another. Here we will refetch
+	// all files, passing the --no-renames flag and then recursively call the function
+	// again for the before file and after file.
+
+	filesWithoutRenames := self.fileLoader.GetStatusFiles(loaders.GetStatusFileOptions{NoRenames: true})
+
+	var beforeFile *models.File
+	var afterFile *models.File
+	for _, f := range filesWithoutRenames {
+		if f.Name == file.PreviousName {
+			beforeFile = f
+		}
+
+		if f.Name == file.Name {
+			afterFile = f
+		}
+	}
+
+	if beforeFile == nil || afterFile == nil {
+		return nil, nil, errors.New("Could not find deleted file or new file for file rename")
+	}
+
+	if beforeFile.IsRename() || afterFile.IsRename() {
+		// probably won't happen but we want to ensure we don't get an infinite loop
+		return nil, nil, errors.New("Nested rename found")
+	}
+
+	return beforeFile, afterFile, nil
+}
+
+// DiscardAllFileChanges directly
+func (self *WorkingTreeCommands) DiscardAllFileChanges(file *models.File) error {
+	if file.IsRename() {
+		beforeFile, afterFile, err := self.BeforeAndAfterFileForRename(file)
+		if err != nil {
+			return err
+		}
+
+		if err := self.DiscardAllFileChanges(beforeFile); err != nil {
+			return err
+		}
+
+		if err := self.DiscardAllFileChanges(afterFile); err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	quotedFileName := self.cmd.Quote(file.Name)
+
+	if file.ShortStatus == "AA" {
+		if err := self.cmd.New("git checkout --ours --  " + quotedFileName).Run(); err != nil {
+			return err
+		}
+		if err := self.cmd.New("git add -- " + quotedFileName).Run(); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	if file.ShortStatus == "DU" {
+		return self.cmd.New("git rm -- " + quotedFileName).Run()
+	}
+
+	// if the file isn't tracked, we assume you want to delete it
+	if file.HasStagedChanges || file.HasMergeConflicts {
+		if err := self.cmd.New("git reset -- " + quotedFileName).Run(); err != nil {
+			return err
+		}
+	}
+
+	if file.ShortStatus == "DD" || file.ShortStatus == "AU" {
+		return nil
+	}
+
+	if file.Added {
+		return self.os.RemoveFile(file.Name)
+	}
+	return self.DiscardUnstagedFileChanges(file)
+}
+
+func (self *WorkingTreeCommands) DiscardAllDirChanges(node *filetree.FileNode) error {
+	// this could be more efficient but we would need to handle all the edge cases
+	return node.ForEachFile(self.DiscardAllFileChanges)
+}
+
+func (self *WorkingTreeCommands) DiscardUnstagedDirChanges(node *filetree.FileNode) error {
+	if err := self.RemoveUntrackedDirFiles(node); err != nil {
+		return err
+	}
+
+	quotedPath := self.cmd.Quote(node.GetPath())
+	if err := self.cmd.New("git checkout -- " + quotedPath).Run(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (self *WorkingTreeCommands) RemoveUntrackedDirFiles(node *filetree.FileNode) error {
+	untrackedFilePaths := node.GetPathsMatching(
+		func(n *filetree.FileNode) bool { return n.File != nil && !n.File.GetIsTracked() },
+	)
+
+	for _, path := range untrackedFilePaths {
+		err := os.Remove(path)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// DiscardUnstagedFileChanges directly
+func (self *WorkingTreeCommands) DiscardUnstagedFileChanges(file *models.File) error {
+	quotedFileName := self.cmd.Quote(file.Name)
+	return self.cmd.New("git checkout -- " + quotedFileName).Run()
+}
+
+// Ignore adds a file to the gitignore for the repo
+func (self *WorkingTreeCommands) Ignore(filename string) error {
+	return self.os.AppendLineToFile(".gitignore", filename)
+}
+
+// WorktreeFileDiff returns the diff of a file
+func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string {
+	// for now we assume an error means the file was deleted
+	s, _ := self.WorktreeFileDiffCmdObj(file, plain, cached, ignoreWhitespace).RunWithOutput()
+	return s
+}
+
+func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) oscommands.ICmdObj {
+	cachedArg := ""
+	trackedArg := "--"
+	colorArg := self.UserConfig.Git.Paging.ColorArg
+	quotedPath := self.cmd.Quote(node.GetPath())
+	ignoreWhitespaceArg := ""
+	contextSize := self.UserConfig.Git.DiffContextSize
+	if cached {
+		cachedArg = " --cached"
+	}
+	if !node.GetIsTracked() && !node.GetHasStagedChanges() && !cached {
+		trackedArg = "--no-index -- /dev/null"
+	}
+	if plain {
+		colorArg = "never"
+	}
+	if ignoreWhitespace {
+		ignoreWhitespaceArg = " --ignore-all-space"
+	}
+
+	cmdStr := fmt.Sprintf("git diff --submodule --no-ext-diff --unified=%d --color=%s%s%s %s %s", contextSize, colorArg, ignoreWhitespaceArg, cachedArg, trackedArg, quotedPath)
+
+	return self.cmd.New(cmdStr).DontLog()
+}
+
+func (self *WorkingTreeCommands) ApplyPatch(patch string, flags ...string) error {
+	filepath := filepath.Join(oscommands.GetTempDir(), utils.GetCurrentRepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".patch")
+	self.Log.Infof("saving temporary patch to %s", filepath)
+	if err := self.os.CreateFileWithContent(filepath, patch); err != nil {
+		return err
+	}
+
+	flagStr := ""
+	for _, flag := range flags {
+		flagStr += " --" + flag
+	}
+
+	return self.cmd.New(fmt.Sprintf("git apply%s %s", flagStr, self.cmd.Quote(filepath))).Run()
+}
+
+// ShowFileDiff get the diff of specified from and to. Typically this will be used for a single commit so it'll be 123abc^..123abc
+// but when we're in diff mode it could be any 'from' to any 'to'. The reverse flag is also here thanks to diff mode.
+func (self *WorkingTreeCommands) ShowFileDiff(from string, to string, reverse bool, fileName string, plain bool) (string, error) {
+	return self.ShowFileDiffCmdObj(from, to, reverse, fileName, plain).RunWithOutput()
+}
+
+func (self *WorkingTreeCommands) ShowFileDiffCmdObj(from string, to string, reverse bool, fileName string, plain bool) oscommands.ICmdObj {
+	colorArg := self.UserConfig.Git.Paging.ColorArg
+	contextSize := self.UserConfig.Git.DiffContextSize
+	if plain {
+		colorArg = "never"
+	}
+
+	reverseFlag := ""
+	if reverse {
+		reverseFlag = " -R"
+	}
+
+	return self.cmd.
+		New(
+			fmt.Sprintf(
+				"git diff --submodule --no-ext-diff --unified=%d --no-renames --color=%s%s%s%s -- %s",
+				contextSize, colorArg, pad(from), pad(to), reverseFlag, self.cmd.Quote(fileName)),
+		).
+		DontLog()
+}
+
+// CheckoutFile checks out the file for the given commit
+func (self *WorkingTreeCommands) CheckoutFile(commitSha, fileName string) error {
+	return self.cmd.New(fmt.Sprintf("git checkout %s -- %s", commitSha, self.cmd.Quote(fileName))).Run()
+}
+
+// DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`
+func (self *WorkingTreeCommands) DiscardAnyUnstagedFileChanges() error {
+	return self.cmd.New("git checkout -- .").Run()
+}
+
+// RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
+func (self *WorkingTreeCommands) RemoveTrackedFiles(name string) error {
+	return self.cmd.New("git rm -r --cached -- " + self.cmd.Quote(name)).Run()
+}
+
+// RemoveUntrackedFiles runs `git clean -fd`
+func (self *WorkingTreeCommands) RemoveUntrackedFiles() error {
+	return self.cmd.New("git clean -fd").Run()
+}
+
+// ResetAndClean removes all unstaged changes and removes all untracked files
+func (self *WorkingTreeCommands) ResetAndClean() error {
+	submoduleConfigs, err := self.submodule.GetConfigs()
+	if err != nil {
+		return err
+	}
+
+	if len(submoduleConfigs) > 0 {
+		if err := self.submodule.ResetSubmodules(submoduleConfigs); err != nil {
+			return err
+		}
+	}
+
+	if err := self.ResetHard("HEAD"); err != nil {
+		return err
+	}
+
+	return self.RemoveUntrackedFiles()
+}
+
+// ResetHardHead runs `git reset --hard`
+func (self *WorkingTreeCommands) ResetHard(ref string) error {
+	return self.cmd.New("git reset --hard " + self.cmd.Quote(ref)).Run()
+}
+
+// ResetSoft runs `git reset --soft HEAD`
+func (self *WorkingTreeCommands) ResetSoft(ref string) error {
+	return self.cmd.New("git reset --soft " + self.cmd.Quote(ref)).Run()
+}
+
+func (self *WorkingTreeCommands) ResetMixed(ref string) error {
+	return self.cmd.New("git reset --mixed " + self.cmd.Quote(ref)).Run()
+}
+
+// so that we don't have unnecessary space in our commands we use this helper function to prepend spaces to args so that in the format string we can go '%s%s%s' and if any args are missing we won't have gaps.
+func pad(str string) string {
+	if str == "" {
+		return ""
+	}
+
+	return " " + str
+}
--- a/pkg/commands/git_commands/working_tree_test.go
+++ b/pkg/commands/git_commands/working_tree_test.go
@@ -1,4 +1,4 @@
-package commands
+package git_commands

 import (
 	"fmt"
@@ -7,22 +7,23 @@ import (
 	"testing"

 	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/stretchr/testify/assert"
 )

-func TestGitCommandStageFile(t *testing.T) {
+func TestWorkingTreeStageFile(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "add", "--", "test.txt"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
+		Expect(`git add -- "test.txt"`, "", nil)

-	assert.NoError(t, gitCmd.StageFile("test.txt"))
+	instance := buildWorkingTreeCommands(commonDeps{runner: runner})
+
+	assert.NoError(t, instance.StageFile("test.txt"))
 	runner.CheckForMissingCalls()
 }

-func TestGitCommandUnstageFile(t *testing.T) {
+func TestWorkingTreeUnstageFile(t *testing.T) {
 	type scenario struct {
 		testName string
 		reset    bool
@@ -35,7 +36,7 @@ func TestGitCommandUnstageFile(t *testing.T) {
 			testName: "Remove an untracked file from staging",
 			reset:    false,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "rm", "--cached", "--force", "--", "test.txt"}, "", nil),
+				Expect(`git rm --cached --force -- "test.txt"`, "", nil),
 			test: func(err error) {
 				assert.NoError(t, err)
 			},
@@ -44,7 +45,7 @@ func TestGitCommandUnstageFile(t *testing.T) {
 			testName: "Remove a tracked file from staging",
 			reset:    true,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "HEAD", "--", "test.txt"}, "", nil),
+				Expect(`git reset HEAD -- "test.txt"`, "", nil),
 			test: func(err error) {
 				assert.NoError(t, err)
 			},
@@ -52,9 +53,10 @@ func TestGitCommandUnstageFile(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.UnStageFile([]string{"test.txt"}, s.reset))
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.UnStageFile([]string{"test.txt"}, s.reset))
 		})
 	}
 }
@@ -62,7 +64,7 @@ func TestGitCommandUnstageFile(t *testing.T) {
 // these tests don't cover everything, in part because we already have an integration
 // test which does cover everything. I don't want to unnecessarily assert on the 'how'
 // when the 'what' is what matters
-func TestGitCommandDiscardAllFileChanges(t *testing.T) {
+func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 	type scenario struct {
 		testName      string
 		file          *models.File
@@ -80,7 +82,7 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", errors.New("error")),
+				Expect(`git reset -- "test"`, "", errors.New("error")),
 			expectedError: "error",
 		},
 		{
@@ -105,7 +107,7 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", errors.New("error")),
+				Expect(`git checkout -- "test"`, "", errors.New("error")),
 			expectedError: "error",
 		},
 		{
@@ -117,7 +119,7 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
+				Expect(`git checkout -- "test"`, "", nil),
 			expectedError: "",
 		},
 		{
@@ -129,8 +131,8 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
+				Expect(`git reset -- "test"`, "", nil).
+				Expect(`git checkout -- "test"`, "", nil),
 			expectedError: "",
 		},
 		{
@@ -142,8 +144,8 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
+				Expect(`git reset -- "test"`, "", nil).
+				Expect(`git checkout -- "test"`, "", nil),
 			expectedError: "",
 		},
 		{
@@ -159,7 +161,7 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 				return nil
 			},
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil),
+				Expect(`git reset -- "test"`, "", nil),
 			expectedError: "",
 		},
 		{
@@ -180,10 +182,10 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.OSCommand.SetRemoveFile(s.removeFile)
-			err := gitCmd.DiscardAllFileChanges(s.file)
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, removeFile: s.removeFile})
+			err := instance.DiscardAllFileChanges(s.file)

 			if s.expectedError == "" {
 				assert.Nil(t, err)
@@ -195,7 +197,7 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 	}
 }

-func TestGitCommandDiff(t *testing.T) {
+func TestWorkingTreeDiff(t *testing.T) {
 	type scenario struct {
 		testName         string
 		file             *models.File
@@ -221,7 +223,7 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always -- "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName: "cached",
@@ -235,7 +237,7 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--cached", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --cached -- "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName: "plain",
@@ -249,7 +251,7 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=never", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=never -- "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName: "File not tracked and file has no staged changes",
@@ -263,7 +265,7 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--no-index", "--", "/dev/null", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --no-index -- /dev/null "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName: "Default case (ignore whitespace)",
@@ -277,7 +279,7 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: true,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--ignore-all-space", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --ignore-all-space -- "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName: "Show diff with custom context size",
@@ -291,22 +293,25 @@ func TestGitCommandDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      17,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=17", "--color=always", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=17 --color=always -- "test.txt"`, expectedResult, nil),
 		},
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			result := gitCmd.WorktreeFileDiff(s.file, s.plain, s.cached, s.ignoreWhitespace)
+			userConfig := config.GetDefaultConfig()
+			userConfig.Git.DiffContextSize = s.contextSize
+
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig})
+			result := instance.WorktreeFileDiff(s.file, s.plain, s.cached, s.ignoreWhitespace)
 			assert.Equal(t, expectedResult, result)
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandShowFileDiff(t *testing.T) {
+func TestWorkingTreeShowFileDiff(t *testing.T) {
 	type scenario struct {
 		testName    string
 		from        string
@@ -328,7 +333,7 @@ func TestGitCommandShowFileDiff(t *testing.T) {
 			plain:       false,
 			contextSize: 3,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--no-renames", "--color=always", "1234567890", "0987654321", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=3 --no-renames --color=always 1234567890 0987654321 -- "test.txt"`, expectedResult, nil),
 		},
 		{
 			testName:    "Show diff with custom context size",
@@ -338,15 +343,19 @@ func TestGitCommandShowFileDiff(t *testing.T) {
 			plain:       false,
 			contextSize: 123,
 			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=123", "--no-renames", "--color=always", "1234567890", "0987654321", "--", "test.txt"}, expectedResult, nil),
+				Expect(`git diff --submodule --no-ext-diff --unified=123 --no-renames --color=always 1234567890 0987654321 -- "test.txt"`, expectedResult, nil),
 		},
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			result, err := gitCmd.ShowFileDiff(s.from, s.to, s.reverse, "test.txt", s.plain)
+			userConfig := config.GetDefaultConfig()
+			userConfig.Git.DiffContextSize = s.contextSize
+
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig})
+
+			result, err := instance.ShowFileDiff(s.from, s.to, s.reverse, "test.txt", s.plain)
 			assert.NoError(t, err)
 			assert.Equal(t, expectedResult, result)
 			s.runner.CheckForMissingCalls()
@@ -354,7 +363,7 @@ func TestGitCommandShowFileDiff(t *testing.T) {
 	}
 }

-func TestGitCommandCheckoutFile(t *testing.T) {
+func TestWorkingTreeCheckoutFile(t *testing.T) {
 	type scenario struct {
 		testName  string
 		commitSha string
@@ -387,15 +396,17 @@ func TestGitCommandCheckoutFile(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CheckoutFile(s.commitSha, s.fileName))
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+
+			s.test(instance.CheckoutFile(s.commitSha, s.fileName))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandApplyPatch(t *testing.T) {
+func TestWorkingTreeApplyPatch(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -405,8 +416,9 @@ func TestGitCommandApplyPatch(t *testing.T) {
 	expectFn := func(regexStr string, errToReturn error) func(cmdObj oscommands.ICmdObj) (string, error) {
 		return func(cmdObj oscommands.ICmdObj) (string, error) {
 			re := regexp.MustCompile(regexStr)
-			matches := re.FindStringSubmatch(cmdObj.ToString())
-			assert.Equal(t, 2, len(matches))
+			cmdStr := cmdObj.ToString()
+			matches := re.FindStringSubmatch(cmdStr)
+			assert.Equal(t, 2, len(matches), fmt.Sprintf("unexpected command: %s", cmdStr))

 			filename := matches[1]

@@ -439,82 +451,16 @@ func TestGitCommandApplyPatch(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.ApplyPatch("test", "cached"))
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.ApplyPatch("test", "cached"))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandDiscardOldFileChanges(t *testing.T) {
-	type scenario struct {
-		testName               string
-		gitConfigMockResponses map[string]string
-		commits                []*models.Commit
-		commitIndex            int
-		fileName               string
-		runner                 *oscommands.FakeCmdObjRunner
-		test                   func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName:               "returns error when index outside of range of commits",
-			gitConfigMockResponses: nil,
-			commits:                []*models.Commit{},
-			commitIndex:            0,
-			fileName:               "test999.txt",
-			runner:                 oscommands.NewFakeRunner(t),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			testName:               "returns error when using gpg",
-			gitConfigMockResponses: map[string]string{"commit.gpgsign": "true"},
-			commits:                []*models.Commit{{Name: "commit", Sha: "123456"}},
-			commitIndex:            0,
-			fileName:               "test999.txt",
-			runner:                 oscommands.NewFakeRunner(t),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			testName:               "checks out file if it already existed",
-			gitConfigMockResponses: nil,
-			commits: []*models.Commit{
-				{Name: "commit", Sha: "123456"},
-				{Name: "commit2", Sha: "abcdef"},
-			},
-			commitIndex: 0,
-			fileName:    "test999.txt",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty abcdef`, "", nil).
-				Expect(`git cat-file -e HEAD^:"test999.txt"`, "", nil).
-				Expect(`git checkout HEAD^ -- "test999.txt"`, "", nil).
-				Expect(`git commit --amend --no-edit --allow-empty`, "", nil).
-				Expect(`git rebase --continue`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		// test for when the file was created within the commit requires a refactor to support proper mocks
-		// currently we'd need to mock out the os.Remove function and that's gonna introduce tech debt
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-			s.test(gitCmd.DiscardOldFileChanges(s.commits, s.commitIndex, s.fileName))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandDiscardUnstagedFileChanges(t *testing.T) {
+func TestWorkingTreeDiscardUnstagedFileChanges(t *testing.T) {
 	type scenario struct {
 		testName string
 		file     *models.File
@@ -535,15 +481,16 @@ func TestGitCommandDiscardUnstagedFileChanges(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.DiscardUnstagedFileChanges(s.file))
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.DiscardUnstagedFileChanges(s.file))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandDiscardAnyUnstagedFileChanges(t *testing.T) {
+func TestWorkingTreeDiscardAnyUnstagedFileChanges(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -562,15 +509,16 @@ func TestGitCommandDiscardAnyUnstagedFileChanges(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.DiscardAnyUnstagedFileChanges())
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.DiscardAnyUnstagedFileChanges())
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestGitCommandRemoveUntrackedFiles(t *testing.T) {
+func TestWorkingTreeRemoveUntrackedFiles(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -589,156 +537,40 @@ func TestGitCommandRemoveUntrackedFiles(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.RemoveUntrackedFiles())
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.RemoveUntrackedFiles())
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }

-func TestEditFileCmdStr(t *testing.T) {
+func TestWorkingTreeResetHard(t *testing.T) {
 	type scenario struct {
-		filename                  string
-		configEditCommand         string
-		configEditCommandTemplate string
-		runner                    *oscommands.FakeCmdObjRunner
-		getenv                    func(string) string
-		gitConfigMockResponses    map[string]string
-		test                      func(string, error)
+		testName string
+		ref      string
+		runner   *oscommands.FakeCmdObjRunner
+		test     func(error)
 	}

 	scenarios := []scenario{
 		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "", errors.New("error")),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.EqualError(t, err, "No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "nano",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
+			"valid case",
+			"HEAD",
+			oscommands.NewFakeRunner(t).
+				Expect(`git reset --hard "HEAD"`, "", nil),
+			func(err error) {
 				assert.NoError(t, err)
-				assert.Equal(t, `nano "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: map[string]string{"core.editor": "nano"},
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `nano "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				if env == "VISUAL" {
-					return "nano"
-				}
-
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				if env == "EDITOR" {
-					return "emacs"
-				}
-
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `emacs "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "/usr/bin/vi", nil),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vi "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "file/with space",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "/usr/bin/vi", nil),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vi "file/with space"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "open file/at line",
-			configEditCommand:         "vim",
-			configEditCommandTemplate: "{{editor}} +{{line}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vim +1 "open file/at line"`, cmdStr)
 			},
 		},
 	}

 	for _, s := range scenarios {
-		gitCmd := NewDummyGitCommandWithRunner(s.runner)
-		gitCmd.UserConfig.OS.EditCommand = s.configEditCommand
-		gitCmd.UserConfig.OS.EditCommandTemplate = s.configEditCommandTemplate
-		gitCmd.OSCommand.Getenv = s.getenv
-		gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-		s.test(gitCmd.EditFileCmdStr(s.filename, 1))
-		s.runner.CheckForMissingCalls()
+		s := s
+		t.Run(s.testName, func(t *testing.T) {
+			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
+			s.test(instance.ResetHard(s.ref))
+		})
 	}
 }
--- a/pkg/commands/git_config/cached_git_config.go
+++ b/pkg/commands/git_config/cached_git_config.go
@@ -1,31 +1,36 @@
 package git_config

 import (
+	"os/exec"
 	"strings"

 	"github.com/sirupsen/logrus"
 )

 type IGitConfig interface {
+	// this is for when you want to pass 'mykey' (it calls `git config --get --null mykey` under the hood)
 	Get(string) string
+	// this is for when you want to pass '--local --get-regexp mykey'
+	GetGeneral(string) string
+	// this is for when you want to pass 'mykey' and check if the result is truthy
 	GetBool(string) bool
 }

 type CachedGitConfig struct {
-	cache  map[string]string
-	getKey func(string) (string, error)
-	log    *logrus.Entry
+	cache           map[string]string
+	runGitConfigCmd func(*exec.Cmd) (string, error)
+	log             *logrus.Entry
 }

 func NewStdCachedGitConfig(log *logrus.Entry) *CachedGitConfig {
-	return NewCachedGitConfig(getGitConfigValue, log)
+	return NewCachedGitConfig(runGitConfigCmd, log)
 }

-func NewCachedGitConfig(getKey func(string) (string, error), log *logrus.Entry) *CachedGitConfig {
+func NewCachedGitConfig(runGitConfigCmd func(*exec.Cmd) (string, error), log *logrus.Entry) *CachedGitConfig {
 	return &CachedGitConfig{
-		cache:  make(map[string]string),
-		getKey: getKey,
-		log:    log,
+		cache:           make(map[string]string),
+		runGitConfigCmd: runGitConfigCmd,
+		log:             log,
 	}
 }

@@ -40,8 +45,30 @@ func (self *CachedGitConfig) Get(key string) string {
 	return value
 }

+func (self *CachedGitConfig) GetGeneral(args string) string {
+	if value, ok := self.cache[args]; ok {
+		self.log.Debugf("using cache for args " + args)
+		return value
+	}
+
+	value := self.getGeneralAux(args)
+	self.cache[args] = value
+	return value
+}
+
+func (self *CachedGitConfig) getGeneralAux(args string) string {
+	cmd := getGitConfigGeneralCmd(args)
+	value, err := self.runGitConfigCmd(cmd)
+	if err != nil {
+		self.log.Debugf("Error getting git config value for args: " + args + ". Error: " + err.Error())
+		return ""
+	}
+	return strings.TrimSpace(value)
+}
+
 func (self *CachedGitConfig) getAux(key string) string {
-	value, err := self.getKey(key)
+	cmd := getGitConfigCmd(key)
+	value, err := self.runGitConfigCmd(cmd)
 	if err != nil {
 		self.log.Debugf("Error getting git config value for key: " + key + ". Error: " + err.Error())
 		return ""
--- a/pkg/commands/git_config/cached_git_config_test.go
+++ b/pkg/commands/git_config/cached_git_config_test.go
@@ -1,6 +1,8 @@
 package git_config

 import (
+	"os/exec"
+	"strings"
 	"testing"

 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -52,8 +54,9 @@ func TestGetBool(t *testing.T) {
 		t.Run(s.testName, func(t *testing.T) {
 			fake := NewFakeGitConfig(s.mockResponses)
 			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
+				func(cmd *exec.Cmd) (string, error) {
+					assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
+					return fake.Get("commit.gpgsign"), nil
 				},
 				utils.NewDummyLog(),
 			)
@@ -88,8 +91,9 @@ func TestGet(t *testing.T) {
 		t.Run(s.testName, func(t *testing.T) {
 			fake := NewFakeGitConfig(s.mockResponses)
 			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
+				func(cmd *exec.Cmd) (string, error) {
+					assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
+					return fake.Get("commit.gpgsign"), nil
 				},
 				utils.NewDummyLog(),
 			)
@@ -101,9 +105,9 @@ func TestGet(t *testing.T) {
 	// verifying that the cache is used
 	count := 0
 	real := NewCachedGitConfig(
-		func(key string) (string, error) {
+		func(cmd *exec.Cmd) (string, error) {
 			count++
-			assert.Equal(t, "commit.gpgsign", key)
+			assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
 			return "blah", nil
 		},
 		utils.NewDummyLog(),
--- a/pkg/commands/git_config/fake_git_config.go
+++ b/pkg/commands/git_config/fake_git_config.go
@@ -17,6 +17,13 @@ func (self *FakeGitConfig) Get(key string) string {
 	return self.mockResponses[key]
 }

+func (self *FakeGitConfig) GetGeneral(args string) string {
+	if self.mockResponses == nil {
+		return ""
+	}
+	return self.mockResponses[args]
+}
+
 func (self *FakeGitConfig) GetBool(key string) bool {
 	return isTruthy(self.Get(key))
 }
--- a/pkg/commands/git_config/get_key.go
+++ b/pkg/commands/git_config/get_key.go
@@ -35,10 +35,8 @@ import (
 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-func getGitConfigValue(key string) (string, error) {
-	gitArgs := []string{"config", "--get", "--null", key}
+func runGitConfigCmd(cmd *exec.Cmd) (string, error) {
 	var stdout bytes.Buffer
-	cmd := secureexec.Command("git", gitArgs...)
 	cmd.Stdout = &stdout
 	cmd.Stderr = ioutil.Discard

@@ -46,7 +44,7 @@ func getGitConfigValue(key string) (string, error) {
 	if exitError, ok := err.(*exec.ExitError); ok {
 		if waitStatus, ok := exitError.Sys().(syscall.WaitStatus); ok {
 			if waitStatus.ExitStatus() == 1 {
-				return "", fmt.Errorf("the key `%s` is not found", key)
+				return "", fmt.Errorf("the key is not found for %s", cmd.Args)
 			}
 		}
 		return "", err
@@ -54,3 +52,13 @@ func getGitConfigValue(key string) (string, error) {

 	return strings.TrimRight(stdout.String(), "\000"), nil
 }
+
+func getGitConfigCmd(key string) *exec.Cmd {
+	gitArgs := []string{"config", "--get", "--null", key}
+	return secureexec.Command("git", gitArgs...)
+}
+
+func getGitConfigGeneralCmd(args string) *exec.Cmd {
+	gitArgs := append([]string{"config"}, strings.Split(args, " ")...)
+	return secureexec.Command("git", gitArgs...)
+}
--- a/pkg/commands/git_test.go
+++ b/pkg/commands/git_test.go
@@ -104,6 +104,7 @@ func TestNavigateToRepoRootDirectory(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(navigateToRepoRootDirectory(s.stat, s.chdir))
 		})
@@ -159,6 +160,7 @@ func TestSetupRepository(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(setupRepository(s.openGitRepository, s.errorStr))
 		})
@@ -206,6 +208,7 @@ func TestNewGitCommand(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.setup()
 			s.test(NewGitCommand(utils.NewDummyCommon(), oscommands.NewDummyOSCommand(), git_config.NewFakeGitConfig(nil)))
@@ -282,6 +285,7 @@ func TestFindDotGitDir(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(findDotGitDir(s.stat, s.readFile))
 		})
--- a/pkg/commands/hosting_service/hosting_service_test.go
+++ b/pkg/commands/hosting_service/hosting_service_test.go
@@ -56,6 +56,7 @@ func TestGetRepoInfoFromURL(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result, err := s.serviceDefinition.getRepoInfoFromURL(s.repoURL)
 			assert.NoError(t, err)
@@ -222,6 +223,7 @@ func TestGetPullRequestURL(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			tr := i18n.EnglishTranslationSet()
 			log := &test.FakeFieldLogger{}
--- a/pkg/commands/loaders/branches.go
+++ b/pkg/commands/loaders/branches.go
@@ -4,6 +4,7 @@ import (
 	"regexp"
 	"strings"

+	"github.com/jesseduffield/go-git/v5/config"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -20,31 +21,34 @@ import (
 // if we find out we need to use one of these functions in the git.go file, we
 // can just pull them out of here and put them there and then call them from in here

+type BranchLoaderConfigCommands interface {
+	Branches() (map[string]*config.Branch, error)
+}
+
 // BranchLoader returns a list of Branch objects for the current repo
 type BranchLoader struct {
 	*common.Common
 	getRawBranches       func() (string, error)
 	getCurrentBranchName func() (string, string, error)
-}
-
-type BranchLoaderGitCommand interface {
-	GetRawBranches() (string, error)
-	CurrentBranchName() (string, string, error)
+	config               BranchLoaderConfigCommands
 }

 func NewBranchLoader(
 	cmn *common.Common,
-	gitCommand BranchLoaderGitCommand,
+	getRawBranches func() (string, error),
+	getCurrentBranchName func() (string, string, error),
+	config BranchLoaderConfigCommands,
 ) *BranchLoader {
 	return &BranchLoader{
 		Common:               cmn,
-		getRawBranches:       gitCommand.GetRawBranches,
-		getCurrentBranchName: gitCommand.CurrentBranchName,
+		getRawBranches:       getRawBranches,
+		getCurrentBranchName: getCurrentBranchName,
+		config:               config,
 	}
 }

 // Load the list of branches for the current repo
-func (self *BranchLoader) Load(reflogCommits []*models.Commit) []*models.Branch {
+func (self *BranchLoader) Load(reflogCommits []*models.Commit) ([]*models.Branch, error) {
 	branches := self.obtainBranches()

 	reflogBranches := self.obtainReflogBranches(reflogCommits)
@@ -81,11 +85,25 @@ outer:
 	if !foundHead {
 		currentBranchName, currentBranchDisplayName, err := self.getCurrentBranchName()
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 		branches = append([]*models.Branch{{Name: currentBranchName, DisplayName: currentBranchDisplayName, Head: true, Recency: "  *"}}, branches...)
 	}
-	return branches
+
+	configBranches, err := self.config.Branches()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, branch := range branches {
+		match := configBranches[branch.Name]
+		if match != nil {
+			branch.UpstreamRemote = match.Remote
+			branch.UpstreamBranch = match.Merge.Short()
+		}
+	}
+
+	return branches, nil
 }

 func (self *BranchLoader) obtainBranches() []*models.Branch {
@@ -120,12 +138,13 @@ func (self *BranchLoader) obtainBranches() []*models.Branch {

 		upstreamName := split[2]
 		if upstreamName == "" {
+			// if we're here then it means we do not have a local version of the remote.
+			// The branch might still be tracking a remote though, we just don't know
+			// how many commits ahead/behind it is
 			branches = append(branches, branch)
 			continue
 		}

-		branch.UpstreamName = upstreamName
-
 		track := split[3]
 		re := regexp.MustCompile(`ahead (\d+)`)
 		match := re.FindStringSubmatch(track)
--- a/pkg/commands/loaders/commit_files.go
+++ b/pkg/commands/loaders/commit_files.go
@@ -28,7 +28,7 @@ func (self *CommitFileLoader) GetFilesInDiff(from string, to string, reverse boo
 		reverseFlag = " -R "
 	}

-	filenames, err := self.cmd.New(fmt.Sprintf("git diff --submodule --no-ext-diff --name-status -z --no-renames %s %s %s", reverseFlag, from, to)).RunWithOutput()
+	filenames, err := self.cmd.New(fmt.Sprintf("git diff --submodule --no-ext-diff --name-status -z --no-renames %s %s %s", reverseFlag, from, to)).DontLog().RunWithOutput()
 	if err != nil {
 		return nil, err
 	}
--- a/pkg/commands/loaders/commits.go
+++ b/pkg/commands/loaders/commits.go
@@ -36,26 +36,22 @@ type CommitLoader struct {
 	dotGitDir            string
 }

-type CommitLoaderGitCommand interface {
-	CurrentBranchName() (string, string, error)
-	RebaseMode() (enums.RebaseMode, error)
-	GetCmd() oscommands.ICmdObjBuilder
-	GetDotGitDir() string
-}
-
 // making our dependencies explicit for the sake of easier testing
 func NewCommitLoader(
 	cmn *common.Common,
-	gitCommand CommitLoaderGitCommand,
+	cmd oscommands.ICmdObjBuilder,
+	dotGitDir string,
+	getCurrentBranchName func() (string, string, error),
+	getRebaseMode func() (enums.RebaseMode, error),
 ) *CommitLoader {
 	return &CommitLoader{
 		Common:               cmn,
-		cmd:                  gitCommand.GetCmd(),
-		getCurrentBranchName: gitCommand.CurrentBranchName,
-		getRebaseMode:        gitCommand.RebaseMode,
+		cmd:                  cmd,
+		getCurrentBranchName: getCurrentBranchName,
+		getRebaseMode:        getRebaseMode,
 		readFile:             ioutil.ReadFile,
 		walkFiles:            filepath.Walk,
-		dotGitDir:            gitCommand.GetDotGitDir(),
+		dotGitDir:            dotGitDir,
 	}
 }

@@ -218,7 +214,7 @@ func (self *CommitLoader) getHydratedRebasingCommits(rebaseMode enums.RebaseMode
 			prettyFormat,
 			20,
 		),
-	)
+	).DontLog()

 	hydratedCommits := make([]*models.Commit, 0, len(commits))
 	i := 0
@@ -278,10 +274,7 @@ func (self *CommitLoader) getNormalRebasingCommits() ([]*models.Commit, error) {
 			return err
 		}
 		content := string(bytesContent)
-		commit, err := self.commitFromPatch(content)
-		if err != nil {
-			return err
-		}
+		commit := self.commitFromPatch(content)
 		commits = append([]*models.Commit{commit}, commits...)
 		return nil
 	})
@@ -338,7 +331,7 @@ func (self *CommitLoader) getInteractiveRebasingCommits() ([]*models.Commit, err
 // From: Lazygit Tester <test@example.com>
 // Date: Wed, 5 Dec 2018 21:03:23 +1100
 // Subject: second commit on master
-func (self *CommitLoader) commitFromPatch(content string) (*models.Commit, error) {
+func (self *CommitLoader) commitFromPatch(content string) *models.Commit {
 	lines := strings.Split(content, "\n")
 	sha := strings.Split(lines[0], " ")[1]
 	name := strings.TrimPrefix(lines[3], "Subject: ")
@@ -346,7 +339,7 @@ func (self *CommitLoader) commitFromPatch(content string) (*models.Commit, error
 		Sha:    sha,
 		Name:   name,
 		Status: "rebasing",
-	}, nil
+	}
 }

 func (self *CommitLoader) setCommitMergedStatuses(refName string, commits []*models.Commit) ([]*models.Commit, error) {
@@ -384,7 +377,7 @@ func (self *CommitLoader) getMergeBase(refName string) (string, error) {
 	}

 	// swallowing error because it's not a big deal; probably because there are no commits yet
-	output, _ := self.cmd.New(fmt.Sprintf("git merge-base %s %s", self.cmd.Quote(refName), self.cmd.Quote(baseBranch))).RunWithOutput()
+	output, _ := self.cmd.New(fmt.Sprintf("git merge-base %s %s", self.cmd.Quote(refName), self.cmd.Quote(baseBranch))).DontLog().RunWithOutput()
 	return ignoringWarnings(output), nil
 }

@@ -405,6 +398,7 @@ func (self *CommitLoader) getFirstPushedCommit(refName string) (string, error) {
 		New(
 			fmt.Sprintf("git merge-base %s %s@{u}", self.cmd.Quote(refName), self.cmd.Quote(refName)),
 		).
+		DontLog().
 		RunWithOutput()
 	if err != nil {
 		return "", err
@@ -444,7 +438,7 @@ func (self *CommitLoader) getLogCmd(opts GetCommitsOptions) oscommands.ICmdObj {
 			20,
 			filterFlag,
 		),
-	)
+	).DontLog()
 }

 var prettyFormat = fmt.Sprintf(
--- a/pkg/commands/loaders/commits_test.go
+++ b/pkg/commands/loaders/commits_test.go
@@ -186,6 +186,7 @@ func TestGetCommits(t *testing.T) {
 	}

 	for _, scenario := range scenarios {
+		scenario := scenario
 		t.Run(scenario.testName, func(t *testing.T) {
 			builder := &CommitLoader{
 				Common: utils.NewDummyCommon(),
--- a/pkg/commands/loaders/files.go
+++ b/pkg/commands/loaders/files.go
@@ -4,26 +4,29 @@ import (
 	"fmt"
 	"strings"

-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

+type FileLoaderConfig interface {
+	GetShowUntrackedFiles() string
+}
+
 type FileLoader struct {
 	*common.Common
 	cmd         oscommands.ICmdObjBuilder
-	gitConfig   git_config.IGitConfig
+	config      FileLoaderConfig
 	getFileType func(string) string
 }

-func NewFileLoader(cmn *common.Common, cmd oscommands.ICmdObjBuilder, gitConfig git_config.IGitConfig) *FileLoader {
+func NewFileLoader(cmn *common.Common, cmd oscommands.ICmdObjBuilder, config FileLoaderConfig) *FileLoader {
 	return &FileLoader{
 		Common:      cmn,
 		cmd:         cmd,
-		gitConfig:   gitConfig,
 		getFileType: oscommands.FileType,
+		config:      config,
 	}
 }

@@ -33,7 +36,7 @@ type GetStatusFileOptions struct {

 func (self *FileLoader) GetStatusFiles(opts GetStatusFileOptions) []*models.File {
 	// check if config wants us ignoring untracked files
-	untrackedFilesSetting := self.gitConfig.Get("status.showUntrackedFiles")
+	untrackedFilesSetting := self.config.GetShowUntrackedFiles()

 	if untrackedFilesSetting == "" {
 		untrackedFilesSetting = "all"
@@ -98,7 +101,7 @@ func (c *FileLoader) GitStatus(opts GitStatusOptions) ([]FileStatus, error) {
 		noRenamesFlag = " --no-renames"
 	}

-	statusLines, err := c.cmd.New(fmt.Sprintf("git status %s --porcelain -z%s", opts.UntrackedFilesArg, noRenamesFlag)).RunWithOutput()
+	statusLines, err := c.cmd.New(fmt.Sprintf("git status %s --porcelain -z%s", opts.UntrackedFilesArg, noRenamesFlag)).DontLog().RunWithOutput()
 	if err != nil {
 		return []FileStatus{}, err
 	}
--- a/pkg/commands/loaders/files_test.go
+++ b/pkg/commands/loaders/files_test.go
@@ -3,14 +3,13 @@ package loaders
 import (
 	"testing"

-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/stretchr/testify/assert"
 )

-func TestGitCommandGetStatusFiles(t *testing.T) {
+func TestFileGetStatusFiles(t *testing.T) {
 	type scenario struct {
 		testName      string
 		runner        oscommands.ICmdObjRunner
@@ -186,14 +185,14 @@ func TestGitCommandGetStatusFiles(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			cmd := oscommands.NewDummyCmdObjBuilder(s.runner)
-			gitConfig := git_config.NewFakeGitConfig(map[string]string{"status.showUntrackedFiles": "yes"})

 			loader := &FileLoader{
 				Common:      utils.NewDummyCommon(),
 				cmd:         cmd,
-				gitConfig:   gitConfig,
+				config:      &FakeFileLoaderConfig{showUntrackedFiles: "yes"},
 				getFileType: func(string) string { return "file" },
 			}

@@ -201,3 +200,11 @@ func TestGitCommandGetStatusFiles(t *testing.T) {
 		})
 	}
 }
+
+type FakeFileLoaderConfig struct {
+	showUntrackedFiles string
+}
+
+func (self *FakeFileLoaderConfig) GetShowUntrackedFiles() string {
+	return self.showUntrackedFiles
+}
--- a/pkg/commands/loaders/reflog_commits.go
+++ b/pkg/commands/loaders/reflog_commits.go
@@ -32,7 +32,7 @@ func (self *ReflogCommitLoader) GetReflogCommits(lastReflogCommit *models.Commit
 		filterPathArg = fmt.Sprintf(" --follow -- %s", self.cmd.Quote(filterPath))
 	}

-	cmdObj := self.cmd.New(fmt.Sprintf(`git log -g --abbrev=20 --format="%%h %%ct %%gs" %s`, filterPathArg))
+	cmdObj := self.cmd.New(fmt.Sprintf(`git log -g --abbrev=20 --format="%%h %%ct %%gs" %s`, filterPathArg)).DontLog()
 	onlyObtainedNewReflogCommits := false
 	err := cmdObj.RunAndProcessLines(func(line string) (bool, error) {
 		fields := strings.SplitN(line, " ", 3)
--- a/pkg/commands/loaders/remotes.go
+++ b/pkg/commands/loaders/remotes.go
@@ -31,7 +31,7 @@ func NewRemoteLoader(
 }

 func (self *RemoteLoader) GetRemotes() ([]*models.Remote, error) {
-	remoteBranchesStr, err := self.cmd.New("git branch -r").RunWithOutput()
+	remoteBranchesStr, err := self.cmd.New("git branch -r").DontLog().RunWithOutput()
 	if err != nil {
 		return nil, err
 	}
--- a/pkg/commands/loaders/stash.go
+++ b/pkg/commands/loaders/stash.go
@@ -31,7 +31,7 @@ func (self *StashLoader) GetStashEntries(filterPath string) []*models.StashEntry
 		return self.getUnfilteredStashEntries()
 	}

-	rawString, err := self.cmd.New("git stash list --name-only").RunWithOutput()
+	rawString, err := self.cmd.New("git stash list --name-only").DontLog().RunWithOutput()
 	if err != nil {
 		return self.getUnfilteredStashEntries()
 	}
@@ -64,7 +64,7 @@ outer:
 }

 func (self *StashLoader) getUnfilteredStashEntries() []*models.StashEntry {
-	rawString, _ := self.cmd.New("git stash list --pretty='%gs'").RunWithOutput()
+	rawString, _ := self.cmd.New("git stash list --pretty='%gs'").DontLog().RunWithOutput()
 	stashEntries := []*models.StashEntry{}
 	for i, line := range utils.SplitLines(rawString) {
 		stashEntries = append(stashEntries, self.stashEntryFromLine(line, i))
--- a/pkg/commands/loaders/stash_test.go
+++ b/pkg/commands/loaders/stash_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )

-func TestGitCommandGetStashEntries(t *testing.T) {
+func TestGetStashEntries(t *testing.T) {
 	type scenario struct {
 		testName             string
 		filterPath           string
@@ -48,12 +48,13 @@ func TestGitCommandGetStashEntries(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			cmd := oscommands.NewDummyCmdObjBuilder(s.runner)

 			loader := NewStashLoader(utils.NewDummyCommon(), cmd)

-			assert.EqualValues(t, s.expectedStashEntries, loader.GetStashEntries(""))
+			assert.EqualValues(t, s.expectedStashEntries, loader.GetStashEntries(s.filterPath))
 		})
 	}
 }
--- a/pkg/commands/loaders/tags.go
+++ b/pkg/commands/loaders/tags.go
@@ -27,7 +27,7 @@ func NewTagLoader(
 func (self *TagLoader) GetTags() ([]*models.Tag, error) {
 	// get remote branches, sorted  by creation date (descending)
 	// see: https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---sortltkeygt
-	remoteBranchesStr, err := self.cmd.New(`git tag --list --sort=-creatordate`).RunWithOutput()
+	remoteBranchesStr, err := self.cmd.New(`git tag --list --sort=-creatordate`).DontLog().RunWithOutput()
 	if err != nil {
 		return nil, err
 	}
--- a/pkg/commands/models/branch.go
+++ b/pkg/commands/models/branch.go
@@ -5,12 +5,16 @@ package models
 type Branch struct {
 	Name string
 	// the displayname is something like '(HEAD detached at 123asdf)', whereas in that case the name would be '123asdf'
-	DisplayName  string
-	Recency      string
-	Pushables    string
-	Pullables    string
-	UpstreamName string
-	Head         bool
+	DisplayName string
+	Recency     string
+	Pushables   string
+	Pullables   string
+	Head        bool
+	// if we have a named remote locally this will be the name of that remote e.g.
+	// 'origin' or 'tiwood'. If we don't have the remote locally it'll look like
+	// 'git@github.com:tiwood/lazygit.git'
+	UpstreamRemote string
+	UpstreamBranch string
 }

 func (b *Branch) RefName() string {
@@ -25,22 +29,26 @@ func (b *Branch) Description() string {
 	return b.RefName()
 }

-// this method does not consider the case where the git config states that a branch is tracking the config.
-// The Pullables value here is based on whether or not we saw an upstream when doing `git branch`
 func (b *Branch) IsTrackingRemote() bool {
-	return b.IsRealBranch() && b.Pullables != "?"
+	return b.UpstreamRemote != ""
+}
+
+// we know that the remote branch is not stored locally based on our pushable/pullable
+// count being question marks.
+func (b *Branch) RemoteBranchStoredLocally() bool {
+	return b.IsTrackingRemote() && b.Pushables != "?" && b.Pullables != "?"
 }

 func (b *Branch) MatchesUpstream() bool {
-	return b.IsRealBranch() && b.Pushables == "0" && b.Pullables == "0"
+	return b.RemoteBranchStoredLocally() && b.Pushables == "0" && b.Pullables == "0"
 }

 func (b *Branch) HasCommitsToPush() bool {
-	return b.IsRealBranch() && b.Pushables != "0"
+	return b.RemoteBranchStoredLocally() && b.Pushables != "0"
 }

 func (b *Branch) HasCommitsToPull() bool {
-	return b.IsRealBranch() && b.Pullables != "0"
+	return b.RemoteBranchStoredLocally() && b.Pullables != "0"
 }

 // for when we're in a detached head state
--- a/pkg/commands/oscommands/cmd_obj.go
+++ b/pkg/commands/oscommands/cmd_obj.go
@@ -12,6 +12,7 @@ type ICmdObj interface {
 	// using NewFromArgs, the output won't be quite the same as what you would type
 	// into a terminal e.g. 'sh -c git commit' as opposed to 'sh -c "git commit"'
 	ToString() string
+
 	AddEnvVars(...string) ICmdObj
 	GetEnvVars() []string

@@ -22,18 +23,54 @@ type ICmdObj interface {
 	// runs the command and runs a callback function on each line of the output. If the callback returns true for the boolean value, we kill the process and return.
 	RunAndProcessLines(onLine func(line string) (bool, error)) error

-	// logs command
-	Log() ICmdObj
+	// Be calling DontLog(), we're saying that once we call Run(), we don't want to
+	// log the command in the UI (it'll still be logged in the log file). The general rule
+	// is that if a command doesn't change the git state (e.g. read commands like `git diff`)
+	// then we don't want to log it. If we are changing something (e.g. `git add .`) then
+	// we do. The only exception is if we're running a command in the background periodically
+	// like `git fetch`, which technically does mutate stuff but isn't something we need
+	// to notify the user about.
+	DontLog() ICmdObj
+
+	// This returns false if DontLog() was called
+	ShouldLog() bool
+
+	PromptOnCredentialRequest() ICmdObj
+	FailOnCredentialRequest() ICmdObj
+
+	GetCredentialStrategy() CredentialStrategy
 }

 type CmdObj struct {
 	cmdStr string
 	cmd    *exec.Cmd

-	runner     ICmdObjRunner
-	logCommand func(ICmdObj)
+	runner ICmdObjRunner
+
+	// if set to true, we don't want to log the command to the user.
+	dontLog bool
+
+	// if set to true, it means we might be asked to enter a username/password by this command.
+	credentialStrategy CredentialStrategy
 }

+type CredentialStrategy int
+
+const (
+	// do not expect a credential request. If we end up getting one
+	// we'll be in trouble because the command will hang indefinitely
+	NONE CredentialStrategy = iota
+	// expect a credential request and if we get one, prompt the user to enter their username/password
+	PROMPT
+	// in this case we will check for a credential request (i.e. the command pauses to ask for
+	// username/password) and if we get one, we just submit a newline, forcing the
+	// command to fail. We use this e.g. for a background `git fetch` to prevent it
+	// from hanging indefinitely.
+	FAIL
+)
+
+var _ ICmdObj = &CmdObj{}
+
 func (self *CmdObj) GetCmd() *exec.Cmd {
 	return self.cmd
 }
@@ -52,12 +89,15 @@ func (self *CmdObj) GetEnvVars() []string {
 	return self.cmd.Env
 }

-func (self *CmdObj) Log() ICmdObj {
-	self.logCommand(self)
-
+func (self *CmdObj) DontLog() ICmdObj {
+	self.dontLog = true
 	return self
 }

+func (self *CmdObj) ShouldLog() bool {
+	return !self.dontLog
+}
+
 func (self *CmdObj) Run() error {
 	return self.runner.Run(self)
 }
@@ -69,3 +109,19 @@ func (self *CmdObj) RunWithOutput() (string, error) {
 func (self *CmdObj) RunAndProcessLines(onLine func(line string) (bool, error)) error {
 	return self.runner.RunAndProcessLines(self, onLine)
 }
+
+func (self *CmdObj) PromptOnCredentialRequest() ICmdObj {
+	self.credentialStrategy = PROMPT
+
+	return self
+}
+
+func (self *CmdObj) FailOnCredentialRequest() ICmdObj {
+	self.credentialStrategy = FAIL
+
+	return self
+}
+
+func (self *CmdObj) GetCredentialStrategy() CredentialStrategy {
+	return self.credentialStrategy
+}
--- a/pkg/commands/oscommands/cmd_obj_builder.go
+++ b/pkg/commands/oscommands/cmd_obj_builder.go
@@ -1,6 +1,7 @@
 package oscommands

 import (
+	"fmt"
 	"os"
 	"strings"

@@ -20,9 +21,8 @@ type ICmdObjBuilder interface {
 }

 type CmdObjBuilder struct {
-	runner    ICmdObjRunner
-	logCmdObj func(ICmdObj)
-	platform  *Platform
+	runner   ICmdObjRunner
+	platform *Platform
 }

 // poor man's version of explicitly saying that struct X implements interface Y
@@ -34,10 +34,9 @@ func (self *CmdObjBuilder) New(cmdStr string) ICmdObj {
 	cmd.Env = os.Environ()

 	return &CmdObj{
-		cmdStr:     cmdStr,
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
+		cmdStr: cmdStr,
+		cmd:    cmd,
+		runner: self.runner,
 	}
 }

@@ -46,23 +45,57 @@ func (self *CmdObjBuilder) NewFromArgs(args []string) ICmdObj {
 	cmd.Env = os.Environ()

 	return &CmdObj{
-		cmdStr:     strings.Join(args, " "),
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
+		cmdStr: strings.Join(args, " "),
+		cmd:    cmd,
+		runner: self.runner,
 	}
 }

 func (self *CmdObjBuilder) NewShell(commandStr string) ICmdObj {
-	return self.NewFromArgs([]string{self.platform.Shell, self.platform.ShellArg, commandStr})
+	quotedCommand := ""
+	// Windows does not seem to like quotes around the command
+	if self.platform.OS == "windows" {
+		quotedCommand = strings.NewReplacer(
+			"^", "^^",
+			"&", "^&",
+			"|", "^|",
+			"<", "^<",
+			">", "^>",
+			"%", "^%",
+		).Replace(commandStr)
+	} else {
+		quotedCommand = self.Quote(commandStr)
+	}
+
+	shellCommand := fmt.Sprintf("%s %s %s", self.platform.Shell, self.platform.ShellArg, quotedCommand)
+	return self.New(shellCommand)
 }

 func (self *CmdObjBuilder) CloneWithNewRunner(decorate func(ICmdObjRunner) ICmdObjRunner) *CmdObjBuilder {
 	decoratedRunner := decorate(self.runner)

 	return &CmdObjBuilder{
-		runner:    decoratedRunner,
-		logCmdObj: self.logCmdObj,
-		platform:  self.platform,
+		runner:   decoratedRunner,
+		platform: self.platform,
 	}
 }
+
+func (self *CmdObjBuilder) Quote(message string) string {
+	var quote string
+	if self.platform.OS == "windows" {
+		quote = `\"`
+		message = strings.NewReplacer(
+			`"`, `"'"'"`,
+			`\"`, `\\"`,
+		).Replace(message)
+	} else {
+		quote = `"`
+		message = strings.NewReplacer(
+			`\`, `\\`,
+			`"`, `\"`,
+			`$`, `\$`,
+			"`", "\\`",
+		).Replace(message)
+	}
+	return quote + message + quote
+}
--- a/pkg/commands/oscommands/cmd_obj_runner.go
+++ b/pkg/commands/oscommands/cmd_obj_runner.go
@@ -2,6 +2,10 @@ package oscommands

 import (
 	"bufio"
+	"bytes"
+	"io"
+	"regexp"
+	"strings"

 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -14,20 +18,45 @@ type ICmdObjRunner interface {
 	RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error
 }

+type CredentialType int
+
+const (
+	Password CredentialType = iota
+	Username
+	Passphrase
+)
+
 type cmdObjRunner struct {
-	log       *logrus.Entry
-	logCmdObj func(ICmdObj)
+	log   *logrus.Entry
+	guiIO *guiIO
 }

 var _ ICmdObjRunner = &cmdObjRunner{}

 func (self *cmdObjRunner) Run(cmdObj ICmdObj) error {
-	_, err := self.RunWithOutput(cmdObj)
-	return err
+	if cmdObj.GetCredentialStrategy() == NONE {
+		_, err := self.RunWithOutput(cmdObj)
+		return err
+	} else {
+		return self.runWithCredentialHandling(cmdObj)
+	}
 }

 func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
-	self.logCmdObj(cmdObj)
+	if cmdObj.GetCredentialStrategy() != NONE {
+		err := self.runWithCredentialHandling(cmdObj)
+		// for now we're not capturing output, just because it would take a little more
+		// effort and there's currently no use case for it. Some commands call RunWithOutput
+		// but ignore the output, hence why we've got this check here.
+		return "", err
+	}
+
+	self.log.WithField("command", cmdObj.ToString()).Debug("RunCommand")
+
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+
 	output, err := sanitisedCommandOutput(cmdObj.GetCmd().CombinedOutput())
 	if err != nil {
 		self.log.WithField("command", cmdObj.ToString()).Error(output)
@@ -36,6 +65,14 @@ func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
 }

 func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
+	if cmdObj.GetCredentialStrategy() != NONE {
+		return errors.New("cannot call RunAndProcessLines with credential strategy. If you're seeing this then a contributor to Lazygit has accidentally called this method! Please raise an issue")
+	}
+
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+
 	cmd := cmdObj.GetCmd()
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
@@ -65,6 +102,30 @@ func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line st
 	return nil
 }

+// Whenever we're asked for a password we just enter a newline, which will
+// eventually cause the command to fail.
+var failPromptFn = func(CredentialType) string { return "\n" }
+
+func (self *cmdObjRunner) runWithCredentialHandling(cmdObj ICmdObj) error {
+	var promptFn func(CredentialType) string
+
+	switch cmdObj.GetCredentialStrategy() {
+	case PROMPT:
+		promptFn = self.guiIO.promptForCredentialFn
+	case FAIL:
+		promptFn = failPromptFn
+	case NONE:
+		// we should never land here
+		return errors.New("runWithCredentialHandling called but cmdObj does not have a a credential strategy")
+	}
+
+	return self.runAndDetectCredentialRequest(cmdObj, promptFn)
+}
+
+func (self *cmdObjRunner) logCmdObj(cmdObj ICmdObj) {
+	self.guiIO.logCommandFn(cmdObj.ToString(), true)
+}
+
 func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	outputString := string(output)
 	if err != nil {
@@ -77,3 +138,99 @@ func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	}
 	return outputString, nil
 }
+
+type cmdHandler struct {
+	stdoutPipe io.Reader
+	stdinPipe  io.Writer
+	close      func() error
+}
+
+// runAndDetectCredentialRequest detect a username / password / passphrase question in a command
+// promptUserForCredential is a function that gets executed when this function detect you need to fillin a password or passphrase
+// The promptUserForCredential argument will be "username", "password" or "passphrase" and expects the user's password/passphrase or username back
+func (self *cmdObjRunner) runAndDetectCredentialRequest(
+	cmdObj ICmdObj,
+	promptUserForCredential func(CredentialType) string,
+) error {
+	cmdWriter := self.guiIO.newCmdWriterFn()
+
+	if cmdObj.ShouldLog() {
+		self.logCmdObj(cmdObj)
+	}
+	self.log.WithField("command", cmdObj.ToString()).Info("RunCommand")
+	cmd := cmdObj.AddEnvVars("LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8").GetCmd()
+
+	var stderr bytes.Buffer
+	cmd.Stderr = io.MultiWriter(cmdWriter, &stderr)
+
+	handler, err := self.getCmdHandler(cmd)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		if closeErr := handler.close(); closeErr != nil {
+			self.log.Error(closeErr)
+		}
+	}()
+
+	tr := io.TeeReader(handler.stdoutPipe, cmdWriter)
+
+	go utils.Safe(func() {
+		self.processOutput(tr, handler.stdinPipe, promptUserForCredential)
+	})
+
+	err = cmd.Wait()
+	if err != nil {
+		return errors.New(stderr.String())
+	}
+
+	return nil
+}
+
+func (self *cmdObjRunner) processOutput(reader io.Reader, writer io.Writer, promptUserForCredential func(CredentialType) string) {
+	checkForCredentialRequest := self.getCheckForCredentialRequestFunc()
+
+	scanner := bufio.NewScanner(reader)
+	scanner.Split(bufio.ScanBytes)
+	for scanner.Scan() {
+		newBytes := scanner.Bytes()
+		askFor, ok := checkForCredentialRequest(newBytes)
+		if ok {
+			toInput := promptUserForCredential(askFor)
+			// If the return data is empty we don't write anything to stdin
+			if toInput != "" {
+				_, _ = writer.Write([]byte(toInput))
+			}
+		}
+	}
+}
+
+// having a function that returns a function because we need to maintain some state inbetween calls hence the closure
+func (self *cmdObjRunner) getCheckForCredentialRequestFunc() func([]byte) (CredentialType, bool) {
+	var ttyText strings.Builder
+	// this function takes each word of output from the command and builds up a string to see if we're being asked for a password
+	return func(newBytes []byte) (CredentialType, bool) {
+		_, err := ttyText.Write(newBytes)
+		if err != nil {
+			self.log.Error(err)
+		}
+
+		prompts := map[string]CredentialType{
+			`Password:`:                              Password,
+			`.+'s password:`:                         Password,
+			`Password\s*for\s*'.+':`:                 Password,
+			`Username\s*for\s*'.+':`:                 Username,
+			`Enter\s*passphrase\s*for\s*key\s*'.+':`: Passphrase,
+		}
+
+		for pattern, askFor := range prompts {
+			if match, _ := regexp.MatchString(pattern, ttyText.String()); match {
+				ttyText.Reset()
+				return askFor, true
+			}
+		}
+
+		return 0, false
+	}
+}
--- a/pkg/commands/oscommands/cmd_obj_runner_default.go
+++ b/pkg/commands/oscommands/cmd_obj_runner_default.go
@@ -0,0 +1,25 @@
+//go:build !windows
+// +build !windows
+
+package oscommands
+
+import (
+	"os/exec"
+
+	"github.com/creack/pty"
+)
+
+// we define this separately for windows and non-windows given that windows does
+// not have great PTY support and we need a PTY to handle a credential request
+func (self *cmdObjRunner) getCmdHandler(cmd *exec.Cmd) (*cmdHandler, error) {
+	ptmx, err := pty.Start(cmd)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cmdHandler{
+		stdoutPipe: ptmx,
+		stdinPipe:  ptmx,
+		close:      ptmx.Close,
+	}, nil
+}
--- a/pkg/commands/oscommands/cmd_obj_runner_win.go
+++ b/pkg/commands/oscommands/cmd_obj_runner_win.go
@@ -0,0 +1,49 @@
+//go:build windows
+// +build windows
+
+package oscommands
+
+import (
+	"bytes"
+	"io"
+	"os/exec"
+	"sync"
+)
+
+type Buffer struct {
+	b bytes.Buffer
+	m sync.Mutex
+}
+
+func (b *Buffer) Read(p []byte) (n int, err error) {
+	b.m.Lock()
+	defer b.m.Unlock()
+	return b.b.Read(p)
+}
+func (b *Buffer) Write(p []byte) (n int, err error) {
+	b.m.Lock()
+	defer b.m.Unlock()
+	return b.b.Write(p)
+}
+
+// TODO: Remove this hack and replace it with a proper way to run commands live on windows. We still have an issue where if a password is requested, the request for a password is written straight to stdout because we can't control the stdout of a subprocess of a subprocess. Keep an eye on https://github.com/creack/pty/pull/109
+func (self *cmdObjRunner) getCmdHandler(cmd *exec.Cmd) (*cmdHandler, error) {
+	stdoutReader, stdoutWriter := io.Pipe()
+	cmd.Stdout = stdoutWriter
+
+	buf := &Buffer{}
+	cmd.Stdin = buf
+
+	if err := cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	// because we don't yet have windows support for a pty, we instead just
+	// pass our standard stream handlers and because there's no pty to close
+	// we pass a no-op function for that.
+	return &cmdHandler{
+		stdoutPipe: stdoutReader,
+		stdinPipe:  buf,
+		close:      func() error { return nil },
+	}, nil
+}
--- a/pkg/commands/oscommands/dummies.go
+++ b/pkg/commands/oscommands/dummies.go
@@ -1,30 +1,62 @@
 package oscommands

 import (
+	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 // NewDummyOSCommand creates a new dummy OSCommand for testing
 func NewDummyOSCommand() *OSCommand {
-	return NewOSCommand(utils.NewDummyCommon())
+	osCmd := NewOSCommand(utils.NewDummyCommon(), dummyPlatform, NewNullGuiIO(utils.NewDummyLog()))
+
+	return osCmd
+}
+
+type OSCommandDeps struct {
+	Common       *common.Common
+	Platform     *Platform
+	GetenvFn     func(string) string
+	RemoveFileFn func(string) error
+	Cmd          *CmdObjBuilder
+}
+
+func NewDummyOSCommandWithDeps(deps OSCommandDeps) *OSCommand {
+	common := deps.Common
+	if common == nil {
+		common = utils.NewDummyCommon()
+	}
+
+	platform := deps.Platform
+	if platform == nil {
+		platform = dummyPlatform
+	}
+
+	return &OSCommand{
+		Common:       common,
+		Platform:     platform,
+		getenvFn:     deps.GetenvFn,
+		removeFileFn: deps.RemoveFileFn,
+		guiIO:        NewNullGuiIO(utils.NewDummyLog()),
+	}
 }

 func NewDummyCmdObjBuilder(runner ICmdObjRunner) *CmdObjBuilder {
 	return &CmdObjBuilder{
-		runner:    runner,
-		logCmdObj: func(ICmdObj) {},
-		platform: &Platform{
-			OS:              "darwin",
-			Shell:           "bash",
-			ShellArg:        "-c",
-			OpenCommand:     "open {{filename}}",
-			OpenLinkCommand: "open {{link}}",
-		},
+		runner:   runner,
+		platform: dummyPlatform,
 	}
 }

+var dummyPlatform = &Platform{
+	OS:              "darwin",
+	Shell:           "bash",
+	ShellArg:        "-c",
+	OpenCommand:     "open {{filename}}",
+	OpenLinkCommand: "open {{link}}",
+}
+
 func NewDummyOSCommandWithRunner(runner *FakeCmdObjRunner) *OSCommand {
-	osCommand := NewOSCommand(utils.NewDummyCommon())
+	osCommand := NewOSCommand(utils.NewDummyCommon(), dummyPlatform, NewNullGuiIO(utils.NewDummyLog()))
 	osCommand.Cmd = NewDummyCmdObjBuilder(runner)

 	return osCommand
--- a/pkg/commands/oscommands/exec_live.go
+++ b/pkg/commands/oscommands/exec_live.go
@@ -1,153 +0,0 @@
-package oscommands
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"os/exec"
-	"regexp"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// DetectUnamePass detect a username / password / passphrase question in a command
-// promptUserForCredential is a function that gets executed when this function detect you need to fillin a password or passphrase
-// The promptUserForCredential argument will be "username", "password" or "passphrase" and expects the user's password/passphrase or username back
-func (c *OSCommand) DetectUnamePass(cmdObj ICmdObj, writer io.Writer, promptUserForCredential func(string) string) error {
-	ttyText := ""
-	errMessage := c.RunCommandWithOutputLive(cmdObj, writer, func(word string) string {
-		ttyText = ttyText + " " + word
-
-		prompts := map[string]string{
-			`.+'s password:`:                         "password",
-			`Password\s*for\s*'.+':`:                 "password",
-			`Username\s*for\s*'.+':`:                 "username",
-			`Enter\s*passphrase\s*for\s*key\s*'.+':`: "passphrase",
-		}
-
-		for pattern, askFor := range prompts {
-			if match, _ := regexp.MatchString(pattern, ttyText); match {
-				ttyText = ""
-				return promptUserForCredential(askFor)
-			}
-		}
-
-		return ""
-	})
-	return errMessage
-}
-
-// Due to a lack of pty support on windows we have RunCommandWithOutputLiveWrapper being defined
-// separate for windows and other OS's
-func (c *OSCommand) RunCommandWithOutputLive(cmdObj ICmdObj, writer io.Writer, handleOutput func(string) string) error {
-	return RunCommandWithOutputLiveWrapper(c, cmdObj, writer, handleOutput)
-}
-
-type cmdHandler struct {
-	stdoutPipe io.Reader
-	stdinPipe  io.Writer
-	close      func() error
-}
-
-// RunCommandWithOutputLiveAux runs a command and return every word that gets written in stdout
-// Output is a function that executes by every word that gets read by bufio
-// As return of output you need to give a string that will be written to stdin
-// NOTE: If the return data is empty it won't write anything to stdin
-func RunCommandWithOutputLiveAux(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	// handleOutput takes a word from stdout and returns a string to be written to stdin.
-	// See DetectUnamePass above for how this is used to check for a username/password request
-	handleOutput func(string) string,
-	startCmd func(cmd *exec.Cmd) (*cmdHandler, error),
-) error {
-	c.Log.WithField("command", cmdObj.ToString()).Info("RunCommand")
-	c.LogCommand(cmdObj.ToString(), true)
-	cmd := cmdObj.AddEnvVars("LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8").GetCmd()
-
-	var stderr bytes.Buffer
-	cmd.Stderr = io.MultiWriter(writer, &stderr)
-
-	handler, err := startCmd(cmd)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		if closeErr := handler.close(); closeErr != nil {
-			c.Log.Error(closeErr)
-		}
-	}()
-
-	tr := io.TeeReader(handler.stdoutPipe, writer)
-
-	go utils.Safe(func() {
-		scanner := bufio.NewScanner(tr)
-		scanner.Split(scanWordsWithNewLines)
-		for scanner.Scan() {
-			text := scanner.Text()
-			output := strings.Trim(text, " ")
-			toInput := handleOutput(output)
-			if toInput != "" {
-				_, _ = handler.stdinPipe.Write([]byte(toInput))
-			}
-		}
-	})
-
-	err = cmd.Wait()
-	if err != nil {
-		return errors.New(stderr.String())
-	}
-
-	return nil
-}
-
-// scanWordsWithNewLines is a copy of bufio.ScanWords but this also captures new lines
-// For specific comments about this function take a look at: bufio.ScanWords
-func scanWordsWithNewLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	start := 0
-	for width := 0; start < len(data); start += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[start:])
-		if !isSpace(r) {
-			break
-		}
-	}
-	for width, i := 0, start; i < len(data); i += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[i:])
-		if isSpace(r) {
-			return i + width, data[start:i], nil
-		}
-	}
-	if atEOF && len(data) > start {
-		return len(data), data[start:], nil
-	}
-	return start, nil, nil
-}
-
-// isSpace is also copied from the bufio package and has been modified to also captures new lines
-// For specific comments about this function take a look at: bufio.isSpace
-func isSpace(r rune) bool {
-	if r <= '\u00FF' {
-		switch r {
-		case ' ', '\t', '\v', '\f':
-			return true
-		case '\u0085', '\u00A0':
-			return true
-		}
-		return false
-	}
-	if '\u2000' <= r && r <= '\u200a' {
-		return true
-	}
-	switch r {
-	case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
-		return true
-	}
-	return false
-}
--- a/pkg/commands/oscommands/exec_live_default.go
+++ b/pkg/commands/oscommands/exec_live_default.go
@@ -1,37 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package oscommands
-
-import (
-	"io"
-	"os/exec"
-
-	"github.com/creack/pty"
-)
-
-func RunCommandWithOutputLiveWrapper(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	output func(string) string,
-) error {
-	return RunCommandWithOutputLiveAux(
-		c,
-		cmdObj,
-		writer,
-		output,
-		func(cmd *exec.Cmd) (*cmdHandler, error) {
-			ptmx, err := pty.Start(cmd)
-			if err != nil {
-				return nil, err
-			}
-
-			return &cmdHandler{
-				stdoutPipe: ptmx,
-				stdinPipe:  ptmx,
-				close:      ptmx.Close,
-			}, nil
-		},
-	)
-}
--- a/pkg/commands/oscommands/exec_live_win.go
+++ b/pkg/commands/oscommands/exec_live_win.go
@@ -1,63 +0,0 @@
-//go:build windows
-// +build windows
-
-package oscommands
-
-import (
-	"bytes"
-	"io"
-	"os/exec"
-	"sync"
-)
-
-type Buffer struct {
-	b bytes.Buffer
-	m sync.Mutex
-}
-
-func (b *Buffer) Read(p []byte) (n int, err error) {
-	b.m.Lock()
-	defer b.m.Unlock()
-	return b.b.Read(p)
-}
-func (b *Buffer) Write(p []byte) (n int, err error) {
-	b.m.Lock()
-	defer b.m.Unlock()
-	return b.b.Write(p)
-}
-
-// RunCommandWithOutputLiveWrapper runs a command live but because of windows compatibility this command can't be ran there
-// TODO: Remove this hack and replace it with a proper way to run commands live on windows. We still have an issue where if a password is requested, the request for a password is written straight to stdout because we can't control the stdout of a subprocess of a subprocess. Keep an eye on https://github.com/creack/pty/pull/109
-func RunCommandWithOutputLiveWrapper(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	output func(string) string,
-) error {
-	return RunCommandWithOutputLiveAux(
-		c,
-		cmdObj,
-		writer,
-		output,
-		func(cmd *exec.Cmd) (*cmdHandler, error) {
-			stdoutReader, stdoutWriter := io.Pipe()
-			cmd.Stdout = stdoutWriter
-
-			buf := &Buffer{}
-			cmd.Stdin = buf
-
-			if err := cmd.Start(); err != nil {
-				return nil, err
-			}
-
-			// because we don't yet have windows support for a pty, we instead just
-			// pass our standard stream handlers and because there's no pty to close
-			// we pass a no-op function for that.
-			return &cmdHandler{
-				stdoutPipe: stdoutReader,
-				stdinPipe:  buf,
-				close:      func() error { return nil },
-			}, nil
-		},
-	)
-}
--- a/pkg/commands/oscommands/fake_cmd_obj_runner.go
+++ b/pkg/commands/oscommands/fake_cmd_obj_runner.go
@@ -3,6 +3,7 @@ package oscommands
 import (
 	"bufio"
 	"fmt"
+	"regexp"
 	"strings"
 	"testing"

@@ -93,10 +94,24 @@ func (self *FakeCmdObjRunner) ExpectArgs(expectedArgs []string, output string, e
 	return self
 }

+func (self *FakeCmdObjRunner) ExpectGitArgs(expectedArgs []string, output string, err error) *FakeCmdObjRunner {
+	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
+		// first arg is 'git' on unix and something like '"C:\\Program Files\\Git\\mingw64\\bin\\git.exe" on windows so we'll just ensure it ends in either 'git' or 'git.exe'
+		re := regexp.MustCompile(`git(\.exe)?$`)
+		args := cmdObj.GetCmd().Args
+		if !re.MatchString(args[0]) {
+			self.t.Errorf("expected first arg to end in .git or .git.exe but was %s", args[0])
+		}
+		assert.EqualValues(self.t, expectedArgs, args[1:], fmt.Sprintf("command %d did not match expectation", self.expectedCmdIndex+1))
+
+		return output, err
+	})
+
+	return self
+}
+
 func (self *FakeCmdObjRunner) CheckForMissingCalls() {
 	if self.expectedCmdIndex < len(self.expectedCmds) {
 		self.t.Errorf("expected command %d to be called, but was not", self.expectedCmdIndex+1)
 	}
-
-	return
 }
--- a/pkg/commands/oscommands/gui_io.go
+++ b/pkg/commands/oscommands/gui_io.go
@@ -0,0 +1,51 @@
+package oscommands
+
+import (
+	"io"
+	"io/ioutil"
+
+	"github.com/sirupsen/logrus"
+)
+
+// this struct captures some IO stuff
+type guiIO struct {
+	// this is for logging anything we want. It'll be written to a log file for the sake
+	// of debugging.
+	log *logrus.Entry
+
+	// this is for us to log the command we're about to run e.g. 'git push'. The GUI
+	// will write this to a log panel so that the user can see which commands are being
+	// run.
+	// The isCommandLineCommand arg is there so that we can style the log differently
+	// depending on whether we're directly outputting a command we're about to run that
+	// will be run on the command line, or if we're using something from Go's standard lib.
+	logCommandFn func(str string, isCommandLineCommand bool)
+	// this is for us to directly write the output of a command. We will do this for
+	// certain commands like 'git push'. The GUI will write this to a command output panel.
+	// We need a new cmd writer per command, hence it being a function.
+	newCmdWriterFn func() io.Writer
+	// this allows us to request info from the user like username/password, in the event
+	// that a command requests it.
+	// the 'credential' arg is something like 'username' or 'password'
+	promptForCredentialFn func(credential CredentialType) string
+}
+
+func NewGuiIO(log *logrus.Entry, logCommandFn func(string, bool), newCmdWriterFn func() io.Writer, promptForCredentialFn func(CredentialType) string) *guiIO {
+	return &guiIO{
+		log:                   log,
+		logCommandFn:          logCommandFn,
+		newCmdWriterFn:        newCmdWriterFn,
+		promptForCredentialFn: promptForCredentialFn,
+	}
+}
+
+// we use this function when we want to access the functionality of our OS struct but we
+// don't have anywhere to log things, or request input from the user.
+func NewNullGuiIO(log *logrus.Entry) *guiIO {
+	return &guiIO{
+		log:                   log,
+		logCommandFn:          func(string, bool) {},
+		newCmdWriterFn:        func() io.Writer { return ioutil.Discard },
+		promptForCredentialFn: failPromptFn,
+	}
+}
--- a/pkg/commands/oscommands/os.go
+++ b/pkg/commands/oscommands/os.go
@@ -20,15 +20,10 @@ import (
 type OSCommand struct {
 	*common.Common
 	Platform *Platform
-	Getenv   func(string) string
+	getenvFn func(string) string
+	guiIO    *guiIO

-	// callback to run before running a command, i.e. for the purposes of logging
-	onRunCommand func(CmdLogEntry)
-
-	// something like 'Staging File': allows us to group cmd logs under a single title
-	CmdLogSpan string
-
-	removeFile func(string) error
+	removeFileFn func(string) error

 	Cmd *CmdObjBuilder
 }
@@ -42,88 +37,26 @@ type Platform struct {
 	OpenLinkCommand string
 }

-// TODO: make these fields private
-type CmdLogEntry struct {
-	// e.g. 'git commit -m "haha"'
-	cmdStr string
-	// Span is something like 'Staging File'. Multiple commands can be grouped under the same
-	// span
-	span string
-
-	// sometimes our command is direct like 'git commit', and sometimes it's a
-	// command to remove a file but through Go's standard library rather than the
-	// command line
-	commandLine bool
-}
-
-func (e CmdLogEntry) GetCmdStr() string {
-	return e.cmdStr
-}
-
-func (e CmdLogEntry) GetSpan() string {
-	return e.span
-}
-
-func (e CmdLogEntry) GetCommandLine() bool {
-	return e.commandLine
-}
-
-func NewCmdLogEntry(cmdStr string, span string, commandLine bool) CmdLogEntry {
-	return CmdLogEntry{cmdStr: cmdStr, span: span, commandLine: commandLine}
-}
-
 // NewOSCommand os command runner
-func NewOSCommand(common *common.Common) *OSCommand {
-	platform := getPlatform()
-
+func NewOSCommand(common *common.Common, platform *Platform, guiIO *guiIO) *OSCommand {
 	c := &OSCommand{
-		Common:     common,
-		Platform:   platform,
-		Getenv:     os.Getenv,
-		removeFile: os.RemoveAll,
+		Common:       common,
+		Platform:     platform,
+		getenvFn:     os.Getenv,
+		removeFileFn: os.RemoveAll,
+		guiIO:        guiIO,
 	}

-	runner := &cmdObjRunner{log: common.Log, logCmdObj: c.LogCmdObj}
-	c.Cmd = &CmdObjBuilder{runner: runner, logCmdObj: c.LogCmdObj, platform: platform}
+	runner := &cmdObjRunner{log: common.Log, guiIO: guiIO}
+	c.Cmd = &CmdObjBuilder{runner: runner, platform: platform}

 	return c
 }

-func (c *OSCommand) WithSpan(span string) *OSCommand {
-	// sometimes .WithSpan(span) will be called where span actually is empty, in
-	// which case we don't need to log anything so we can just return early here
-	// with the original struct
-	if span == "" {
-		return c
-	}
-
-	newOSCommand := &OSCommand{}
-	*newOSCommand = *c
-	newOSCommand.CmdLogSpan = span
-	newOSCommand.Cmd.logCmdObj = newOSCommand.LogCmdObj
-	newOSCommand.Cmd.runner = &cmdObjRunner{log: c.Log, logCmdObj: newOSCommand.LogCmdObj}
-	return newOSCommand
-}
-
-func (c *OSCommand) LogCmdObj(cmdObj ICmdObj) {
-	c.LogCommand(cmdObj.ToString(), true)
-}
-
 func (c *OSCommand) LogCommand(cmdStr string, commandLine bool) {
 	c.Log.WithField("command", cmdStr).Info("RunCommand")

-	if c.onRunCommand != nil && c.CmdLogSpan != "" {
-		c.onRunCommand(NewCmdLogEntry(cmdStr, c.CmdLogSpan, commandLine))
-	}
-}
-
-func (c *OSCommand) SetOnRunCommand(f func(CmdLogEntry)) {
-	c.onRunCommand = f
-}
-
-// To be used for testing only
-func (c *OSCommand) SetRemoveFile(f func(string) error) {
-	c.removeFile = f
+	c.guiIO.logCommandFn(cmdStr, commandLine)
 }

 // FileType tells us if the file is a file, directory or other
@@ -138,7 +71,6 @@ func FileType(path string) string {
 	return "file"
 }

-// OpenFile opens a file with the given
 func (c *OSCommand) OpenFile(filename string) error {
 	commandTemplate := c.UserConfig.OS.OpenCommand
 	templateValues := map[string]string{
@@ -148,9 +80,7 @@ func (c *OSCommand) OpenFile(filename string) error {
 	return c.Cmd.NewShell(command).Run()
 }

-// OpenLink opens a file with the given
 func (c *OSCommand) OpenLink(link string) error {
-	c.LogCommand(fmt.Sprintf("Opening link '%s'", link), false)
 	commandTemplate := c.UserConfig.OS.OpenLinkCommand
 	templateValues := map[string]string{
 		"link": c.Quote(link),
@@ -165,26 +95,6 @@ func (c *OSCommand) Quote(message string) string {
 	return c.Cmd.Quote(message)
 }

-func (self *CmdObjBuilder) Quote(message string) string {
-	var quote string
-	if self.platform.OS == "windows" {
-		quote = `\"`
-		message = strings.NewReplacer(
-			`"`, `"'"'"`,
-			`\"`, `\\"`,
-		).Replace(message)
-	} else {
-		quote = `"`
-		message = strings.NewReplacer(
-			`\`, `\\`,
-			`"`, `\"`,
-			`$`, `\$`,
-			"`", "\\`",
-		).Replace(message)
-	}
-	return quote + message + quote
-}
-
 // AppendLineToFile adds a new line in file
 func (c *OSCommand) AppendLineToFile(filename, line string) error {
 	c.LogCommand(fmt.Sprintf("Appending '%s' to file '%s'", line, filename), false)
@@ -256,15 +166,6 @@ func (c *OSCommand) FileExists(path string) (bool, error) {
 	return true, nil
 }

-// GetLazygitPath returns the path of the currently executed file
-func (c *OSCommand) GetLazygitPath() string {
-	ex, err := os.Executable() // get the executable path for git to use
-	if err != nil {
-		ex = os.Args[0] // fallback to the first call argument if needed
-	}
-	return `"` + filepath.ToSlash(ex) + `"`
-}
-
 // PipeCommands runs a heap of commands and pipes their inputs/outputs together like A | B | C
 func (c *OSCommand) PipeCommands(commandStrings ...string) error {
 	cmds := make([]*exec.Cmd, len(commandStrings))
@@ -347,9 +248,22 @@ func (c *OSCommand) CopyToClipboard(str string) error {
 func (c *OSCommand) RemoveFile(path string) error {
 	c.LogCommand(fmt.Sprintf("Deleting path '%s'", path), false)

-	return c.removeFile(path)
+	return c.removeFileFn(path)
+}
+
+func (c *OSCommand) Getenv(key string) string {
+	return c.getenvFn(key)
 }

 func GetTempDir() string {
 	return filepath.Join(os.TempDir(), "lazygit")
 }
+
+// GetLazygitPath returns the path of the currently executed file
+func GetLazygitPath() string {
+	ex, err := os.Executable() // get the executable path for git to use
+	if err != nil {
+		ex = os.Args[0] // fallback to the first call argument if needed
+	}
+	return `"` + filepath.ToSlash(ex) + `"`
+}
--- a/pkg/commands/oscommands/os_default_platform.go
+++ b/pkg/commands/oscommands/os_default_platform.go
@@ -7,7 +7,7 @@ import (
 	"runtime"
 )

-func getPlatform() *Platform {
+func GetPlatform() *Platform {
 	return &Platform{
 		OS:              runtime.GOOS,
 		Shell:           "bash",
--- a/pkg/commands/oscommands/os_test.go
+++ b/pkg/commands/oscommands/os_test.go
@@ -190,6 +190,7 @@ func TestOSCommandCreateTempFile(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(NewDummyOSCommand().CreateTempFile(s.filename, s.content))
 		})
--- a/pkg/commands/oscommands/os_test_default.go
+++ b/pkg/commands/oscommands/os_test_default.go
@@ -4,7 +4,6 @@
 package oscommands

 import (
-	"os/exec"
 	"testing"

 	"github.com/go-errors/errors"
@@ -59,7 +58,6 @@ func TestOSCommandOpenFileLinux(t *testing.T) {
 	type scenario struct {
 		filename string
 		runner   *FakeCmdObjRunner
-		command  func(string, ...string) *exec.Cmd
 		test     func(error)
 	}

@@ -114,69 +112,3 @@ func TestOSCommandOpenFileLinux(t *testing.T) {
 		s.test(oSCmd.OpenFile(s.filename))
 	}
 }
-
-func TestOSCommandOpenFileWindows(t *testing.T) {
-	type scenario struct {
-		filename string
-		runner   *FakeCmdObjRunner
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			filename: "test",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", errors.New("error")),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			filename: "test",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "filename with spaces",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "filename with spaces"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "let's_test_with_single_quote",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "let's_test_with_single_quote"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "$USER.txt",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "$USER.txt"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		oSCmd := NewDummyOSCommandWithRunner(s.runner)
-		platform := &Platform{
-			OS:       "windows",
-			Shell:    "cmd",
-			ShellArg: "/c",
-		}
-		oSCmd.Platform = platform
-		oSCmd.Cmd.platform = platform
-		oSCmd.UserConfig.OS.OpenCommand = `start "" {{filename}}`
-
-		s.test(oSCmd.OpenFile(s.filename))
-	}
-}
--- a/pkg/commands/oscommands/os_test_windows.go
+++ b/pkg/commands/oscommands/os_test_windows.go
@@ -4,18 +4,18 @@
 package oscommands

 import (
-	"os/exec"
 	"testing"

-	"github.com/jesseduffield/lazygit/pkg/secureexec"
+	"github.com/go-errors/errors"
 	"github.com/stretchr/testify/assert"
 )

+// handling this in a separate file because str.ToArgv has different behaviour if we're on windows
+
 func TestOSCommandOpenFileWindows(t *testing.T) {
 	type scenario struct {
 		filename string
 		runner   *FakeCmdObjRunner
-		command  func(string, ...string) *exec.Cmd
 		test     func(error)
 	}

--- a/pkg/commands/oscommands/os_windows.go
+++ b/pkg/commands/oscommands/os_windows.go
@@ -1,6 +1,6 @@
 package oscommands

-func getPlatform() *Platform {
+func GetPlatform() *Platform {
 	return &Platform{
 		OS:       "windows",
 		Shell:    "cmd",
--- a/pkg/commands/patch/patch_manager.go
+++ b/pkg/commands/patch/patch_manager.go
@@ -34,7 +34,7 @@ type PatchManager struct {
 	// To is the commit sha if we're dealing with files of a commit, or a stash ref for a stash
 	To      string
 	From    string
-	Reverse bool
+	reverse bool

 	// CanRebase tells us whether we're allowed to modify our commits. CanRebase should be true for commits of the currently checked out branch and false for everything else
 	// TODO: move this out into a proper mode struct in the gui package: it doesn't really belong here
@@ -43,18 +43,18 @@ type PatchManager struct {
 	// fileInfoMap starts empty but you add files to it as you go along
 	fileInfoMap map[string]*fileInfo
 	Log         *logrus.Entry
-	ApplyPatch  applyPatchFunc
+	applyPatch  applyPatchFunc

-	// LoadFileDiff loads the diff of a file, for a given to (typically a commit SHA)
-	LoadFileDiff loadFileDiffFunc
+	// loadFileDiff loads the diff of a file, for a given to (typically a commit SHA)
+	loadFileDiff loadFileDiffFunc
 }

 // NewPatchManager returns a new PatchManager
 func NewPatchManager(log *logrus.Entry, applyPatch applyPatchFunc, loadFileDiff loadFileDiffFunc) *PatchManager {
 	return &PatchManager{
 		Log:          log,
-		ApplyPatch:   applyPatch,
-		LoadFileDiff: loadFileDiff,
+		applyPatch:   applyPatch,
+		loadFileDiff: loadFileDiff,
 	}
 }

@@ -62,7 +62,7 @@ func NewPatchManager(log *logrus.Entry, applyPatch applyPatchFunc, loadFileDiff
 func (p *PatchManager) Start(from, to string, reverse bool, canRebase bool) {
 	p.To = to
 	p.From = from
-	p.Reverse = reverse
+	p.reverse = reverse
 	p.CanRebase = canRebase
 	p.fileInfoMap = map[string]*fileInfo{}
 }
@@ -118,7 +118,7 @@ func (p *PatchManager) getFileInfo(filename string) (*fileInfo, error) {
 		return info, nil
 	}

-	diff, err := p.LoadFileDiff(p.From, p.To, p.Reverse, filename, true)
+	diff, err := p.loadFileDiff(p.From, p.To, p.reverse, filename, true)
 	if err != nil {
 		return nil, err
 	}
@@ -265,7 +265,7 @@ func (p *PatchManager) ApplyPatches(reverse bool) error {
 			if patch == "" {
 				continue
 			}
-			if err = p.ApplyPatch(patch, applyFlags...); err != nil {
+			if err = p.applyPatch(patch, applyFlags...); err != nil {
 				continue
 			}
 			break
@@ -301,5 +301,5 @@ func (p *PatchManager) IsEmpty() bool {

 // if any of these things change we'll need to reset and start a new patch
 func (p *PatchManager) NewPatchRequired(from string, to string, reverse bool) bool {
-	return from != p.From || to != p.To || reverse != p.Reverse
+	return from != p.From || to != p.To || reverse != p.reverse
 }
--- a/pkg/commands/patch/patch_modifier.go
+++ b/pkg/commands/patch/patch_modifier.go
@@ -22,7 +22,7 @@ func GetHeaderFromDiff(diff string) string {
 func GetHunksFromDiff(diff string) []*PatchHunk {
 	hunks := []*PatchHunk{}
 	firstLineIdx := -1
-	var hunkLines []string
+	var hunkLines []string //nolint:prealloc
 	pastDiffHeader := false

 	for lineIdx, line := range strings.SplitAfter(diff, "\n") {
--- a/pkg/commands/patch/patch_modifier_test.go
+++ b/pkg/commands/patch/patch_modifier_test.go
@@ -511,6 +511,7 @@ func TestModifyPatchForRange(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result := ModifiedPatchForRange(nil, s.filename, s.diffText, s.firstLineIndex, s.lastLineIndex, s.reverse, false)
 			if !assert.Equal(t, s.expected, result) {
@@ -538,6 +539,7 @@ func TestLineNumberOfLine(t *testing.T) {
 	}

 	for _, s := range scenarios {
+		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result := s.hunk.LineNumberOfLine(s.idx)
 			if !assert.Equal(t, s.expected, result) {
--- a/pkg/commands/patch/patch_parser.go
+++ b/pkg/commands/patch/patch_parser.go
@@ -98,7 +98,7 @@ func (l *PatchLine) render(selected bool, included bool) string {
 		return coloredString(style.FgCyan, match[1], selected, included) + coloredString(theme.DefaultTextColor, match[2], selected, false)
 	}

-	textStyle := theme.DefaultTextColor
+	var textStyle style.TextStyle
 	switch l.Kind {
 	case PATCH_HEADER:
 		textStyle = textStyle.SetBold()
@@ -108,6 +108,8 @@ func (l *PatchLine) render(selected bool, included bool) string {
 		textStyle = style.FgRed
 	case COMMIT_SHA:
 		textStyle = style.FgYellow
+	default:
+		textStyle = theme.DefaultTextColor
 	}

 	return coloredString(textStyle, content, selected, included)
--- a/pkg/commands/patch_rebases.go
+++ b/pkg/commands/patch_rebases.go
@@ -1,232 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/patch"
-	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
-)
-
-// DeletePatchesFromCommit applies a patch in reverse for a commit
-func (c *GitCommand) DeletePatchesFromCommit(commits []*models.Commit, commitIndex int, p *patch.PatchManager) error {
-	if err := c.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
-		return err
-	}
-
-	// apply each patch in reverse
-	if err := p.ApplyPatches(true); err != nil {
-		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// time to amend the selected commit
-	if err := c.AmendHead(); err != nil {
-		return err
-	}
-
-	c.onSuccessfulContinue = func() error {
-		c.PatchManager.Reset()
-		return nil
-	}
-
-	// continue
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceCommitIdx int, destinationCommitIdx int, p *patch.PatchManager) error {
-	if sourceCommitIdx < destinationCommitIdx {
-		if err := c.BeginInteractiveRebaseForCommit(commits, destinationCommitIdx); err != nil {
-			return err
-		}
-
-		// apply each patch forward
-		if err := p.ApplyPatches(false); err != nil {
-			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-				return err
-			}
-			return err
-		}
-
-		// amend the destination commit
-		if err := c.AmendHead(); err != nil {
-			return err
-		}
-
-		c.onSuccessfulContinue = func() error {
-			c.PatchManager.Reset()
-			return nil
-		}
-
-		// continue
-		return c.GenericMergeOrRebaseAction("rebase", "continue")
-	}
-
-	if len(commits)-1 < sourceCommitIdx {
-		return errors.New("index outside of range of commits")
-	}
-
-	// we can make this GPG thing possible it just means we need to do this in two parts:
-	// one where we handle the possibility of a credential request, and the other
-	// where we continue the rebase
-	if c.UsingGpg() {
-		return errors.New(c.Tr.DisabledForGPG)
-	}
-
-	baseIndex := sourceCommitIdx + 1
-	todo := ""
-	for i, commit := range commits[0:baseIndex] {
-		a := "pick"
-		if i == sourceCommitIdx || i == destinationCommitIdx {
-			a = "edit"
-		}
-		todo = a + " " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand(commits[baseIndex].Sha, todo, true)
-	if err != nil {
-		return err
-	}
-
-	if err := cmdObj.Run(); err != nil {
-		return err
-	}
-
-	// apply each patch in reverse
-	if err := p.ApplyPatches(true); err != nil {
-		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// amend the source commit
-	if err := c.AmendHead(); err != nil {
-		return err
-	}
-
-	if c.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	c.onSuccessfulContinue = func() error {
-		// now we should be up to the destination, so let's apply forward these patches to that.
-		// ideally we would ensure we're on the right commit but I'm not sure if that check is necessary
-		if err := p.ApplyPatches(false); err != nil {
-			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-				return err
-			}
-			return err
-		}
-
-		// amend the destination commit
-		if err := c.AmendHead(); err != nil {
-			return err
-		}
-
-		c.onSuccessfulContinue = func() error {
-			c.PatchManager.Reset()
-			return nil
-		}
-
-		return c.GenericMergeOrRebaseAction("rebase", "continue")
-	}
-
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, p *patch.PatchManager, stash bool) error {
-	if stash {
-		if err := c.StashSave(c.Tr.StashPrefix + commits[commitIdx].Sha); err != nil {
-			return err
-		}
-	}
-
-	if err := c.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
-		return err
-	}
-
-	if err := p.ApplyPatches(true); err != nil {
-		if c.WorkingTreeState() == enums.REBASE_MODE_REBASING {
-			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-				return err
-			}
-		}
-		return err
-	}
-
-	// amend the commit
-	if err := c.AmendHead(); err != nil {
-		return err
-	}
-
-	if c.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	c.onSuccessfulContinue = func() error {
-		// add patches to index
-		if err := p.ApplyPatches(false); err != nil {
-			if c.WorkingTreeState() == enums.REBASE_MODE_REBASING {
-				if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-					return err
-				}
-			}
-			return err
-		}
-
-		if stash {
-			if err := c.StashDo(0, "apply"); err != nil {
-				return err
-			}
-		}
-
-		c.PatchManager.Reset()
-		return nil
-	}
-
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-func (c *GitCommand) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx int, p *patch.PatchManager) error {
-	if err := c.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
-		return err
-	}
-
-	if err := p.ApplyPatches(true); err != nil {
-		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// amend the commit
-	if err := c.AmendHead(); err != nil {
-		return err
-	}
-
-	// add patches to index
-	if err := p.ApplyPatches(false); err != nil {
-		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
-			return err
-		}
-		return err
-	}
-
-	head_message, _ := c.GetHeadCommitMessage()
-	new_message := fmt.Sprintf("Split from \"%s\"", head_message)
-	err := c.CommitCmdObj(new_message, "").Run()
-	if err != nil {
-		return err
-	}
-
-	if c.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	c.PatchManager.Reset()
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
--- a/pkg/commands/rebasing.go
+++ b/pkg/commands/rebasing.go
@@ -1,280 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"path/filepath"
-	"strings"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-func (c *GitCommand) RewordCommit(commits []*models.Commit, index int) (oscommands.ICmdObj, error) {
-	todo, sha, err := c.GenerateGenericRebaseTodo(commits, index, "reword")
-	if err != nil {
-		return nil, err
-	}
-
-	return c.PrepareInteractiveRebaseCommand(sha, todo, false)
-}
-
-func (c *GitCommand) MoveCommitDown(commits []*models.Commit, index int) error {
-	// we must ensure that we have at least two commits after the selected one
-	if len(commits) <= index+2 {
-		// assuming they aren't picking the bottom commit
-		return errors.New(c.Tr.NoRoom)
-	}
-
-	todo := ""
-	orderedCommits := append(commits[0:index], commits[index+1], commits[index])
-	for _, commit := range orderedCommits {
-		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand(commits[index+2].Sha, todo, true)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-func (c *GitCommand) InteractiveRebase(commits []*models.Commit, index int, action string) error {
-	todo, sha, err := c.GenerateGenericRebaseTodo(commits, index, action)
-	if err != nil {
-		return err
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand(sha, todo, true)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-// PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase
-// we tell git to run lazygit to edit the todo list, and we pass the client
-// lazygit a todo string to write to the todo file
-func (c *GitCommand) PrepareInteractiveRebaseCommand(baseSha string, todo string, overrideEditor bool) (oscommands.ICmdObj, error) {
-	ex := c.OSCommand.GetLazygitPath()
-
-	debug := "FALSE"
-	if c.Debug {
-		debug = "TRUE"
-	}
-
-	cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty %s", baseSha)
-	c.Log.WithField("command", cmdStr).Info("RunCommand")
-
-	cmdObj := c.Cmd.New(cmdStr)
-
-	gitSequenceEditor := ex
-	if todo == "" {
-		gitSequenceEditor = "true"
-	} else {
-		c.OSCommand.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
-	}
-
-	cmdObj.AddEnvVars(
-		"LAZYGIT_CLIENT_COMMAND=INTERACTIVE_REBASE",
-		"LAZYGIT_REBASE_TODO="+todo,
-		"DEBUG="+debug,
-		"LANG=en_US.UTF-8",   // Force using EN as language
-		"LC_ALL=en_US.UTF-8", // Force using EN as language
-		"GIT_SEQUENCE_EDITOR="+gitSequenceEditor,
-	)
-
-	if overrideEditor {
-		cmdObj.AddEnvVars("GIT_EDITOR=" + ex)
-	}
-
-	return cmdObj, nil
-}
-
-func (c *GitCommand) GenerateGenericRebaseTodo(commits []*models.Commit, actionIndex int, action string) (string, string, error) {
-	baseIndex := actionIndex + 1
-
-	if len(commits) <= baseIndex {
-		return "", "", errors.New(c.Tr.CannotRebaseOntoFirstCommit)
-	}
-
-	if action == "squash" || action == "fixup" {
-		baseIndex++
-
-		if len(commits) <= baseIndex {
-			return "", "", errors.New(c.Tr.CannotSquashOntoSecondCommit)
-		}
-	}
-
-	todo := ""
-	for i, commit := range commits[0:baseIndex] {
-		var commitAction string
-		if i == actionIndex {
-			commitAction = action
-		} else if commit.IsMerge() {
-			// your typical interactive rebase will actually drop merge commits by default. Damn git CLI, you scary!
-			// doing this means we don't need to worry about rebasing over merges which always causes problems.
-			// you typically shouldn't be doing rebases that pass over merge commits anyway.
-			commitAction = "drop"
-		} else {
-			commitAction = "pick"
-		}
-		todo = commitAction + " " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	return todo, commits[baseIndex].Sha, nil
-}
-
-// AmendTo amends the given commit with whatever files are staged
-func (c *GitCommand) AmendTo(sha string) error {
-	if err := c.CreateFixupCommit(sha); err != nil {
-		return err
-	}
-
-	return c.SquashAllAboveFixupCommits(sha)
-}
-
-// EditRebaseTodo sets the action at a given index in the git-rebase-todo file
-func (c *GitCommand) EditRebaseTodo(index int, action string) error {
-	fileName := filepath.Join(c.DotGitDir, "rebase-merge/git-rebase-todo")
-	bytes, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return err
-	}
-
-	content := strings.Split(string(bytes), "\n")
-	commitCount := c.getTodoCommitCount(content)
-
-	// we have the most recent commit at the bottom whereas the todo file has
-	// it at the bottom, so we need to subtract our index from the commit count
-	contentIndex := commitCount - 1 - index
-	splitLine := strings.Split(content[contentIndex], " ")
-	content[contentIndex] = action + " " + strings.Join(splitLine[1:], " ")
-	result := strings.Join(content, "\n")
-
-	return ioutil.WriteFile(fileName, []byte(result), 0644)
-}
-
-func (c *GitCommand) getTodoCommitCount(content []string) int {
-	// count lines that are not blank and are not comments
-	commitCount := 0
-	for _, line := range content {
-		if line != "" && !strings.HasPrefix(line, "#") {
-			commitCount++
-		}
-	}
-	return commitCount
-}
-
-// MoveTodoDown moves a rebase todo item down by one position
-func (c *GitCommand) MoveTodoDown(index int) error {
-	fileName := filepath.Join(c.DotGitDir, "rebase-merge/git-rebase-todo")
-	bytes, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return err
-	}
-
-	content := strings.Split(string(bytes), "\n")
-	commitCount := c.getTodoCommitCount(content)
-	contentIndex := commitCount - 1 - index
-
-	rearrangedContent := append(content[0:contentIndex-1], content[contentIndex], content[contentIndex-1])
-	rearrangedContent = append(rearrangedContent, content[contentIndex+1:]...)
-	result := strings.Join(rearrangedContent, "\n")
-
-	return ioutil.WriteFile(fileName, []byte(result), 0644)
-}
-
-// SquashAllAboveFixupCommits squashes all fixup! commits above the given one
-func (c *GitCommand) SquashAllAboveFixupCommits(sha string) error {
-	return c.runSkipEditorCommand(
-		fmt.Sprintf(
-			"git rebase --interactive --autostash --autosquash %s^",
-			sha,
-		),
-	)
-}
-
-// BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current
-// commit and pick all others. After this you'll want to call `c.GenericMergeOrRebaseAction("rebase", "continue")`
-func (c *GitCommand) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error {
-	if len(commits)-1 < commitIndex {
-		return errors.New("index outside of range of commits")
-	}
-
-	// we can make this GPG thing possible it just means we need to do this in two parts:
-	// one where we handle the possibility of a credential request, and the other
-	// where we continue the rebase
-	if c.UsingGpg() {
-		return errors.New(c.Tr.DisabledForGPG)
-	}
-
-	todo, sha, err := c.GenerateGenericRebaseTodo(commits, commitIndex, "edit")
-	if err != nil {
-		return err
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand(sha, todo, true)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-// RebaseBranch interactive rebases onto a branch
-func (c *GitCommand) RebaseBranch(branchName string) error {
-	cmdObj, err := c.PrepareInteractiveRebaseCommand(branchName, "", false)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-// GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
-// By default we skip the editor in the case where a commit will be made
-func (c *GitCommand) GenericMergeOrRebaseAction(commandType string, command string) error {
-	err := c.runSkipEditorCommand(
-		fmt.Sprintf(
-			"git %s --%s",
-			commandType,
-			command,
-		),
-	)
-	if err != nil {
-		if !strings.Contains(err.Error(), "no rebase in progress") {
-			return err
-		}
-		c.Log.Warn(err)
-	}
-
-	// sometimes we need to do a sequence of things in a rebase but the user needs to
-	// fix merge conflicts along the way. When this happens we queue up the next step
-	// so that after the next successful rebase continue we can continue from where we left off
-	if commandType == "rebase" && command == "continue" && c.onSuccessfulContinue != nil {
-		f := c.onSuccessfulContinue
-		c.onSuccessfulContinue = nil
-		return f()
-	}
-	if command == "abort" {
-		c.onSuccessfulContinue = nil
-	}
-	return nil
-}
-
-func (c *GitCommand) runSkipEditorCommand(command string) error {
-	cmdObj := c.OSCommand.Cmd.New(command)
-	lazyGitPath := c.OSCommand.GetLazygitPath()
-	return cmdObj.
-		AddEnvVars(
-			"LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY",
-			"GIT_EDITOR="+lazyGitPath,
-			"EDITOR="+lazyGitPath,
-			"VISUAL="+lazyGitPath,
-		).
-		Run()
-}
--- a/pkg/commands/rebasing_test.go
+++ b/pkg/commands/rebasing_test.go
@@ -1,76 +0,0 @@
-package commands
-
-import (
-	"regexp"
-	"testing"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandRebaseBranch(t *testing.T) {
-	type scenario struct {
-		testName string
-		arg      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "successful rebase",
-			arg:      "master",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty master`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			testName: "unsuccessful rebase",
-			arg:      "master",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty master`, "", errors.New("error")),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.RebaseBranch(s.arg))
-		})
-	}
-}
-
-// TestGitCommandSkipEditorCommand confirms that SkipEditorCommand injects
-// environment variables that suppress an interactive editor
-func TestGitCommandSkipEditorCommand(t *testing.T) {
-	commandStr := "git blah"
-	runner := oscommands.NewFakeRunner(t).ExpectFunc(func(cmdObj oscommands.ICmdObj) (string, error) {
-		assert.Equal(t, commandStr, cmdObj.ToString())
-		envVars := cmdObj.GetEnvVars()
-		for _, regexStr := range []string{
-			`^VISUAL=.*$`,
-			`^EDITOR=.*$`,
-			`^GIT_EDITOR=.*$`,
-			"^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$",
-		} {
-			foundMatch := utils.IncludesStringFunc(envVars, func(envVar string) bool {
-				return regexp.MustCompile(regexStr).MatchString(envVar)
-			})
-			if !foundMatch {
-				t.Errorf("expected environment variable %s to be set", regexStr)
-			}
-		}
-		return "", nil
-	})
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-	err := gitCmd.runSkipEditorCommand(commandStr)
-	assert.NoError(t, err)
-	runner.CheckForMissingCalls()
-}
--- a/pkg/commands/remotes.go
+++ b/pkg/commands/remotes.go
@@ -1,59 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-func (c *GitCommand) AddRemote(name string, url string) error {
-	return c.Cmd.
-		New(fmt.Sprintf("git remote add %s %s", c.Cmd.Quote(name), c.Cmd.Quote(url))).
-		Run()
-}
-
-func (c *GitCommand) RemoveRemote(name string) error {
-	return c.Cmd.
-		New(fmt.Sprintf("git remote remove %s", c.Cmd.Quote(name))).
-		Run()
-}
-
-func (c *GitCommand) RenameRemote(oldRemoteName string, newRemoteName string) error {
-	return c.Cmd.
-		New(fmt.Sprintf("git remote rename %s %s", c.Cmd.Quote(oldRemoteName), c.Cmd.Quote(newRemoteName))).
-		Run()
-}
-
-func (c *GitCommand) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
-	return c.Cmd.
-		New(fmt.Sprintf("git remote set-url %s %s", c.Cmd.Quote(remoteName), c.Cmd.Quote(updatedUrl))).
-		Run()
-}
-
-func (c *GitCommand) DeleteRemoteBranch(remoteName string, branchName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git push %s --delete %s", c.Cmd.Quote(remoteName), c.Cmd.Quote(branchName))
-	cmdObj := c.Cmd.
-		New(command)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
-}
-
-func (c *GitCommand) DetectUnamePass(cmdObj oscommands.ICmdObj, promptUserForCredential func(string) string) error {
-	return c.OSCommand.DetectUnamePass(cmdObj, c.GetCmdWriter(), promptUserForCredential)
-}
-
-// CheckRemoteBranchExists Returns remote branch
-func (c *GitCommand) CheckRemoteBranchExists(branchName string) bool {
-	_, err := c.Cmd.
-		New(
-			fmt.Sprintf("git show-ref --verify -- refs/remotes/origin/%s",
-				c.Cmd.Quote(branchName),
-			)).
-		RunWithOutput()
-
-	return err == nil
-}
-
-// GetRemoteURL returns current repo remote url
-func (c *GitCommand) GetRemoteURL() string {
-	return c.GitConfig.Get("remote.origin.url")
-}
--- a/pkg/commands/stash_entries.go
+++ b/pkg/commands/stash_entries.go
@@ -1,65 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
-)
-
-// StashDo modify stash
-func (c *GitCommand) StashDo(index int, method string) error {
-	return c.Cmd.New(fmt.Sprintf("git stash %s stash@{%d}", method, index)).Run()
-}
-
-// StashSave save stash
-// TODO: before calling this, check if there is anything to save
-func (c *GitCommand) StashSave(message string) error {
-	return c.Cmd.New("git stash save " + c.OSCommand.Quote(message)).Run()
-}
-
-// GetStashEntryDiff stash diff
-func (c *GitCommand) ShowStashEntryCmdStr(index int) string {
-	return fmt.Sprintf("git stash show -p --stat --color=%s --unified=%d stash@{%d}", c.colorArg(), c.UserConfig.Git.DiffContextSize, index)
-}
-
-// StashSaveStagedChanges stashes only the currently staged changes. This takes a few steps
-// shoutouts to Joe on https://stackoverflow.com/questions/14759748/stashing-only-staged-changes-in-git-is-it-possible
-func (c *GitCommand) StashSaveStagedChanges(message string) error {
-	// wrap in 'writing', which uses a mutex
-	if err := c.Cmd.New("git stash --keep-index").Run(); err != nil {
-		return err
-	}
-
-	if err := c.StashSave(message); err != nil {
-		return err
-	}
-
-	if err := c.Cmd.New("git stash apply stash@{1}").Run(); err != nil {
-		return err
-	}
-
-	if err := c.OSCommand.PipeCommands("git stash show -p", "git apply -R"); err != nil {
-		return err
-	}
-
-	if err := c.Cmd.New("git stash drop stash@{1}").Run(); err != nil {
-		return err
-	}
-
-	// if you had staged an untracked file, that will now appear as 'AD' in git status
-	// meaning it's deleted in your working tree but added in your index. Given that it's
-	// now safely stashed, we need to remove it.
-	files := loaders.
-		NewFileLoader(c.Common, c.Cmd, c.GitConfig).
-		GetStatusFiles(loaders.GetStatusFileOptions{})
-
-	for _, file := range files {
-		if file.ShortStatus == "AD" {
-			if err := c.UnStageFile(file.Names(), false); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
--- a/pkg/commands/stash_entries_test.go
+++ b/pkg/commands/stash_entries_test.go
@@ -1,59 +0,0 @@
-package commands
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandStashDo(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "stash", "drop", "stash@{1}"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.StashDo(1, "drop"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandStashSave(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "stash", "save", "A stash message"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.StashSave("A stash message"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandShowStashEntryCmdStr(t *testing.T) {
-	type scenario struct {
-		testName    string
-		index       int
-		contextSize int
-		expected    string
-	}
-
-	scenarios := []scenario{
-		{
-			testName:    "Default case",
-			index:       5,
-			contextSize: 3,
-			expected:    "git stash show -p --stat --color=always --unified=3 stash@{5}",
-		},
-		{
-			testName:    "Show diff with custom context size",
-			index:       5,
-			contextSize: 77,
-			expected:    "git stash show -p --stat --color=always --unified=77 stash@{5}",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			cmdStr := gitCmd.ShowStashEntryCmdStr(s.index)
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
--- a/pkg/commands/status.go
+++ b/pkg/commands/status.go
@@ -1,49 +0,0 @@
-package commands
-
-import (
-	"path/filepath"
-
-	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
-)
-
-// RebaseMode returns "" for non-rebase mode, "normal" for normal rebase
-// and "interactive" for interactive rebase
-func (c *GitCommand) RebaseMode() (enums.RebaseMode, error) {
-	exists, err := c.OSCommand.FileExists(filepath.Join(c.DotGitDir, "rebase-apply"))
-	if err != nil {
-		return enums.REBASE_MODE_NONE, err
-	}
-	if exists {
-		return enums.REBASE_MODE_NORMAL, nil
-	}
-	exists, err = c.OSCommand.FileExists(filepath.Join(c.DotGitDir, "rebase-merge"))
-	if exists {
-		return enums.REBASE_MODE_INTERACTIVE, err
-	} else {
-		return enums.REBASE_MODE_NONE, err
-	}
-}
-
-func (c *GitCommand) WorkingTreeState() enums.RebaseMode {
-	rebaseMode, _ := c.RebaseMode()
-	if rebaseMode != enums.REBASE_MODE_NONE {
-		return enums.REBASE_MODE_REBASING
-	}
-	merging, _ := c.IsInMergeState()
-	if merging {
-		return enums.REBASE_MODE_MERGING
-	}
-	return enums.REBASE_MODE_NONE
-}
-
-// IsInMergeState states whether we are still mid-merge
-func (c *GitCommand) IsInMergeState() (bool, error) {
-	return c.OSCommand.FileExists(filepath.Join(c.DotGitDir, "MERGE_HEAD"))
-}
-
-func (c *GitCommand) IsBareRepo() bool {
-	// note: could use `git rev-parse --is-bare-repository` if we wanna drop go-git
-	_, err := c.Repo.Worktree()
-	return err == gogit.ErrIsBareRepository
-}
--- a/pkg/commands/sync.go
+++ b/pkg/commands/sync.go
@@ -1,120 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-// Push pushes to a branch
-type PushOpts struct {
-	Force          bool
-	UpstreamRemote string
-	UpstreamBranch string
-	SetUpstream    bool
-}
-
-func (c *GitCommand) PushCmdObj(opts PushOpts) (oscommands.ICmdObj, error) {
-	cmdStr := "git push"
-
-	if opts.Force {
-		cmdStr += " --force-with-lease"
-	}
-
-	if opts.SetUpstream {
-		cmdStr += " --set-upstream"
-	}
-
-	if opts.UpstreamRemote != "" {
-		cmdStr += " " + c.OSCommand.Quote(opts.UpstreamRemote)
-	}
-
-	if opts.UpstreamBranch != "" {
-		if opts.UpstreamRemote == "" {
-			return nil, errors.New(c.Tr.MustSpecifyOriginError)
-		}
-		cmdStr += " " + c.OSCommand.Quote(opts.UpstreamBranch)
-	}
-
-	cmdObj := c.Cmd.New(cmdStr)
-	return cmdObj, nil
-}
-
-func (c *GitCommand) Push(opts PushOpts, promptUserForCredential func(string) string) error {
-	cmdObj, err := c.PushCmdObj(opts)
-	if err != nil {
-		return err
-	}
-
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
-}
-
-type FetchOptions struct {
-	PromptUserForCredential func(string) string
-	RemoteName              string
-	BranchName              string
-}
-
-// Fetch fetch git repo
-func (c *GitCommand) Fetch(opts FetchOptions) error {
-	cmdStr := "git fetch"
-
-	if opts.RemoteName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.RemoteName))
-	}
-	if opts.BranchName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.BranchName))
-	}
-
-	cmdObj := c.Cmd.New(cmdStr)
-	return c.DetectUnamePass(cmdObj, func(question string) string {
-		if opts.PromptUserForCredential != nil {
-			return opts.PromptUserForCredential(question)
-		}
-		return "\n"
-	})
-}
-
-type PullOptions struct {
-	PromptUserForCredential func(string) string
-	RemoteName              string
-	BranchName              string
-	FastForwardOnly         bool
-}
-
-func (c *GitCommand) Pull(opts PullOptions) error {
-	if opts.PromptUserForCredential == nil {
-		return errors.New("PromptUserForCredential is required")
-	}
-
-	cmdStr := "git pull --no-edit"
-
-	if opts.FastForwardOnly {
-		cmdStr += " --ff-only"
-	}
-
-	if opts.RemoteName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.RemoteName))
-	}
-	if opts.BranchName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.BranchName))
-	}
-
-	// setting GIT_SEQUENCE_EDITOR to ':' as a way of skipping it, in case the user
-	// has 'pull.rebase = interactive' configured.
-	cmdObj := c.Cmd.New(cmdStr).AddEnvVars("GIT_SEQUENCE_EDITOR=:")
-	return c.DetectUnamePass(cmdObj, opts.PromptUserForCredential)
-}
-
-func (c *GitCommand) FastForward(branchName string, remoteName string, remoteBranchName string, promptUserForCredential func(string) string) error {
-	cmdStr := fmt.Sprintf("git fetch %s %s:%s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))
-	cmdObj := c.Cmd.New(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
-}
-
-func (c *GitCommand) FetchRemote(remoteName string, promptUserForCredential func(string) string) error {
-	cmdStr := fmt.Sprintf("git fetch %s", c.OSCommand.Quote(remoteName))
-	cmdObj := c.Cmd.New(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
-}
--- a/pkg/commands/tags.go
+++ b/pkg/commands/tags.go
@@ -1,23 +0,0 @@
-package commands
-
-import (
-	"fmt"
-)
-
-func (c *GitCommand) CreateLightweightTag(tagName string, commitSha string) error {
-	return c.Cmd.New(fmt.Sprintf("git tag -- %s %s", c.OSCommand.Quote(tagName), commitSha)).Run()
-}
-
-func (c *GitCommand) CreateAnnotatedTag(tagName, commitSha, msg string) error {
-	return c.Cmd.New(fmt.Sprintf("git tag %s %s -m %s", tagName, commitSha, c.OSCommand.Quote(msg))).Run()
-}
-
-func (c *GitCommand) DeleteTag(tagName string) error {
-	return c.Cmd.New(fmt.Sprintf("git tag -d %s", c.OSCommand.Quote(tagName))).Run()
-}
-
-func (c *GitCommand) PushTag(remoteName string, tagName string, promptUserForCredential func(string) string) error {
-	cmdStr := fmt.Sprintf("git push %s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(tagName))
-	cmdObj := c.Cmd.New(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
-}
--- a/pkg/gui/app_status_manager.go
+++ b/pkg/gui/app_status_manager.go
@@ -4,7 +4,6 @@ import (
 	"sync"
 	"time"

-	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -96,11 +95,13 @@ func (gui *Gui) renderAppStatus() {
 		defer ticker.Stop()
 		for range ticker.C {
 			appStatus := gui.statusManager.getStatusString()
+			gui.OnUIThread(func() error {
+				return gui.renderString(gui.Views.AppStatus, appStatus)
+			})
+
 			if appStatus == "" {
-				gui.renderString(gui.Views.AppStatus, "")
 				return
 			}
-			gui.renderString(gui.Views.AppStatus, appStatus)
 		}
 	})
 }
@@ -117,7 +118,7 @@ func (gui *Gui) WithWaitingStatus(message string, f func() error) error {
 		gui.renderAppStatus()

 		if err := f(); err != nil {
-			gui.g.Update(func(g *gocui.Gui) error {
+			gui.OnUIThread(func() error {
 				return gui.surfaceError(err)
 			})
 		}
--- a/pkg/gui/branches_panel.go
+++ b/pkg/gui/branches_panel.go
@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"strings"

-	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -32,7 +31,7 @@ func (gui *Gui) branchesRenderToMain() error {
 	if branch == nil {
 		task = NewRenderStringTask(gui.Tr.NoBranchesThisRepo)
 	} else {
-		cmdObj := gui.GitCommand.GetBranchGraphCmdObj(branch.Name)
+		cmdObj := gui.Git.Branch.GetGraphCmdObj(branch.Name)

 		task = NewRunPtyTask(cmdObj.GetCmd())
 	}
@@ -55,13 +54,18 @@ func (gui *Gui) refreshBranches() {
 		// which allows us to order them correctly. So if we're filtering we'll just
 		// manually load all the reflog commits here
 		var err error
-		reflogCommits, _, err = gui.GitCommand.Loaders.ReflogCommits.GetReflogCommits(nil, "")
+		reflogCommits, _, err = gui.Git.Loaders.ReflogCommits.GetReflogCommits(nil, "")
 		if err != nil {
 			gui.Log.Error(err)
 		}
 	}

-	gui.State.Branches = gui.GitCommand.Loaders.Branches.Load(reflogCommits)
+	branches, err := gui.Git.Loaders.Branches.Load(reflogCommits)
+	if err != nil {
+		_ = gui.surfaceError(err)
+	}
+
+	gui.State.Branches = branches

 	if err := gui.postRefreshUpdate(gui.State.Contexts.Branches); err != nil {
 		gui.Log.Error(err)
@@ -80,7 +84,8 @@ func (gui *Gui) handleBranchPress() error {
 		return gui.createErrorPanel(gui.Tr.AlreadyCheckedOutBranch)
 	}
 	branch := gui.getSelectedBranch()
-	return gui.handleCheckoutRef(branch.Name, handleCheckoutRefOptions{span: gui.Tr.Spans.CheckoutBranch})
+	gui.logAction(gui.Tr.Actions.CheckoutBranch)
+	return gui.handleCheckoutRef(branch.Name, handleCheckoutRefOptions{})
 }

 func (gui *Gui) handleCreatePullRequestPress() error {
@@ -103,7 +108,7 @@ func (gui *Gui) handleCopyPullRequestURLPress() error {

 	branch := gui.getSelectedBranch()

-	branchExistsOnRemote := gui.GitCommand.CheckRemoteBranchExists(branch.Name)
+	branchExistsOnRemote := gui.Git.Remote.CheckRemoteBranchExists(branch.Name)

 	if !branchExistsOnRemote {
 		return gui.surfaceError(errors.New(gui.Tr.NoBranchOnRemote))
@@ -113,12 +118,11 @@ func (gui *Gui) handleCopyPullRequestURLPress() error {
 	if err != nil {
 		return gui.surfaceError(err)
 	}
-	if err := gui.GitCommand.OSCommand.CopyToClipboard(url); err != nil {
+	gui.logAction(gui.Tr.Actions.CopyPullRequestURL)
+	if err := gui.OSCommand.CopyToClipboard(url); err != nil {
 		return gui.surfaceError(err)
 	}

-	gui.OnRunCommand(oscommands.NewCmdLogEntry(fmt.Sprintf("Copying to clipboard: '%s'", url), "Copy URL", false))
-
 	gui.raiseToast(gui.Tr.PullRequestURLCopiedToClipboard)

 	return nil
@@ -128,8 +132,9 @@ func (gui *Gui) handleGitFetch() error {
 	if err := gui.createLoaderPanel(gui.Tr.FetchWait); err != nil {
 		return err
 	}
+
 	go utils.Safe(func() {
-		err := gui.fetch(true, "Fetch")
+		err := gui.fetch()
 		gui.handleCredentialsPopup(err)
 		_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 	})
@@ -145,7 +150,8 @@ func (gui *Gui) handleForceCheckout() error {
 		title:  title,
 		prompt: message,
 		handleConfirm: func() error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.ForceCheckoutBranch).Checkout(branch.Name, commands.CheckoutOptions{Force: true}); err != nil {
+			gui.logAction(gui.Tr.Actions.ForceCheckoutBranch)
+			if err := gui.Git.Branch.Checkout(branch.Name, git_commands.CheckoutOptions{Force: true}); err != nil {
 				_ = gui.surfaceError(err)
 			}
 			return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
@@ -157,7 +163,6 @@ type handleCheckoutRefOptions struct {
 	WaitingStatus string
 	EnvVars       []string
 	onRefNotFound func(ref string) error
-	span          string
 }

 func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions) error {
@@ -166,7 +171,7 @@ func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions)
 		waitingStatus = gui.Tr.CheckingOutStatus
 	}

-	cmdOptions := commands.CheckoutOptions{Force: false, EnvVars: options.EnvVars}
+	cmdOptions := git_commands.CheckoutOptions{Force: false, EnvVars: options.EnvVars}

 	onSuccess := func() {
 		gui.State.Panels.Branches.SelectedLineIdx = 0
@@ -175,10 +180,8 @@ func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions)
 		gui.State.Panels.Commits.LimitCommits = true
 	}

-	gitCommand := gui.GitCommand.WithSpan(options.span)
-
 	return gui.WithWaitingStatus(waitingStatus, func() error {
-		if err := gitCommand.Checkout(ref, cmdOptions); err != nil {
+		if err := gui.Git.Branch.Checkout(ref, cmdOptions); err != nil {
 			// note, this will only work for english-language git commands. If we force git to use english, and the error isn't this one, then the user will receive an english command they may not understand. I'm not sure what the best solution to this is. Running the command once in english and a second time in the native language is one option

 			if options.onRefNotFound != nil && strings.Contains(err.Error(), "did not match any file(s) known to git") {
@@ -192,15 +195,15 @@ func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions)
 					title:  gui.Tr.AutoStashTitle,
 					prompt: gui.Tr.AutoStashPrompt,
 					handleConfirm: func() error {
-						if err := gitCommand.StashSave(gui.Tr.StashPrefix + ref); err != nil {
+						if err := gui.Git.Stash.Save(gui.Tr.StashPrefix + ref); err != nil {
 							return gui.surfaceError(err)
 						}
-						if err := gitCommand.Checkout(ref, cmdOptions); err != nil {
+						if err := gui.Git.Branch.Checkout(ref, cmdOptions); err != nil {
 							return gui.surfaceError(err)
 						}

 						onSuccess()
-						if err := gitCommand.StashDo(0, "pop"); err != nil {
+						if err := gui.Git.Stash.Pop(0); err != nil {
 							if err := gui.refreshSidePanels(refreshOptions{mode: BLOCK_UI}); err != nil {
 								return err
 							}
@@ -226,10 +229,9 @@ func (gui *Gui) handleCheckoutByName() error {
 		title:               gui.Tr.BranchName + ":",
 		findSuggestionsFunc: gui.getRefsSuggestionsFunc(),
 		handleConfirm: func(response string) error {
+			gui.logAction("Checkout branch")
 			return gui.handleCheckoutRef(response, handleCheckoutRefOptions{
-				span: "Checkout branch",
 				onRefNotFound: func(ref string) error {
-
 					return gui.ask(askOpts{
 						title:  gui.Tr.BranchNotFoundTitle,
 						prompt: fmt.Sprintf("%s %s%s", gui.Tr.BranchNotFoundPrompt, ref, "?"),
@@ -257,7 +259,7 @@ func (gui *Gui) createNewBranchWithName(newBranchName string) error {
 		return nil
 	}

-	if err := gui.GitCommand.NewBranch(newBranchName, branch.Name); err != nil {
+	if err := gui.Git.Branch.New(newBranchName, branch.Name); err != nil {
 		return gui.surfaceError(err)
 	}

@@ -300,7 +302,8 @@ func (gui *Gui) deleteNamedBranch(selectedBranch *models.Branch, force bool) err
 		title:  title,
 		prompt: message,
 		handleConfirm: func() error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.DeleteBranch).DeleteBranch(selectedBranch.Name, force); err != nil {
+			gui.logAction(gui.Tr.Actions.DeleteBranch)
+			if err := gui.Git.Branch.Delete(selectedBranch.Name, force); err != nil {
 				errMessage := err.Error()
 				if !force && strings.Contains(errMessage, "git branch -D ") {
 					return gui.deleteNamedBranch(selectedBranch, true)
@@ -317,7 +320,7 @@ func (gui *Gui) mergeBranchIntoCheckedOutBranch(branchName string) error {
 		return err
 	}

-	if gui.GitCommand.IsHeadDetached() {
+	if gui.Git.Branch.IsHeadDetached() {
 		return gui.createErrorPanel("Cannot merge branch in detached head state. You might have checked out a commit directly or a remote branch, in which case you should checkout the local branch you want to be on")
 	}
 	checkedOutBranchName := gui.getCheckedOutBranch().Name
@@ -336,7 +339,8 @@ func (gui *Gui) mergeBranchIntoCheckedOutBranch(branchName string) error {
 		title:  gui.Tr.MergingTitle,
 		prompt: prompt,
 		handleConfirm: func() error {
-			err := gui.GitCommand.WithSpan(gui.Tr.Spans.Merge).Merge(branchName, commands.MergeOpts{})
+			gui.logAction(gui.Tr.Actions.Merge)
+			err := gui.Git.Branch.Merge(branchName, git_commands.MergeOpts{})
 			return gui.handleGenericMergeCommandResult(err)
 		},
 	})
@@ -377,7 +381,8 @@ func (gui *Gui) handleRebaseOntoBranch(selectedBranchName string) error {
 		title:  gui.Tr.RebasingTitle,
 		prompt: prompt,
 		handleConfirm: func() error {
-			err := gui.GitCommand.WithSpan(gui.Tr.Spans.RebaseBranch).RebaseBranch(selectedBranchName)
+			gui.logAction(gui.Tr.Actions.RebaseBranch)
+			err := gui.Git.Rebase.RebaseBranch(selectedBranchName)
 			return gui.handleGenericMergeCommandResult(err)
 		},
 	})
@@ -392,25 +397,19 @@ func (gui *Gui) handleFastForward() error {
 	if !branch.IsTrackingRemote() {
 		return gui.createErrorPanel(gui.Tr.FwdNoUpstream)
 	}
+	if !branch.RemoteBranchStoredLocally() {
+		return gui.createErrorPanel(gui.Tr.FwdNoLocalUpstream)
+	}
 	if branch.HasCommitsToPush() {
 		return gui.createErrorPanel(gui.Tr.FwdCommitsToPush)
 	}

-	upstream, err := gui.GitCommand.GetUpstreamForBranch(branch.Name)
-	if err != nil {
-		return gui.surfaceError(err)
-	}
-
-	span := gui.Tr.Spans.FastForwardBranch
-
-	split := strings.Split(upstream, "/")
-	remoteName := split[0]
-	remoteBranchName := strings.Join(split[1:], "/")
+	action := gui.Tr.Actions.FastForwardBranch

 	message := utils.ResolvePlaceholderString(
 		gui.Tr.Fetching,
 		map[string]string{
-			"from": fmt.Sprintf("%s/%s", remoteName, remoteBranchName),
+			"from": fmt.Sprintf("%s/%s", branch.UpstreamRemote, branch.UpstreamBranch),
 			"to":   branch.Name,
 		},
 	)
@@ -418,9 +417,10 @@ func (gui *Gui) handleFastForward() error {
 		_ = gui.createLoaderPanel(message)

 		if gui.State.Panels.Branches.SelectedLineIdx == 0 {
-			_ = gui.pullWithLock(PullFilesOptions{span: span, FastForwardOnly: true})
+			_ = gui.pullWithLock(PullFilesOptions{action: action, FastForwardOnly: true})
 		} else {
-			err := gui.GitCommand.WithSpan(span).FastForward(branch.Name, remoteName, remoteBranchName, gui.promptUserForCredential)
+			gui.logAction(action)
+			err := gui.Git.Sync.FastForward(branch.Name, branch.UpstreamRemote, branch.UpstreamBranch)
 			gui.handleCredentialsPopup(err)
 			_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{BRANCHES}})
 		}
@@ -448,7 +448,8 @@ func (gui *Gui) handleRenameBranch() error {
 			title:          gui.Tr.NewBranchNamePrompt + " " + branch.Name + ":",
 			initialContent: branch.Name,
 			handleConfirm: func(newBranchName string) error {
-				if err := gui.GitCommand.WithSpan(gui.Tr.Spans.RenameBranch).RenameBranch(branch.Name, newBranchName); err != nil {
+				gui.logAction(gui.Tr.Actions.RenameBranch)
+				if err := gui.Git.Branch.Rename(branch.Name, newBranchName); err != nil {
 					return gui.surfaceError(err)
 				}

@@ -516,7 +517,8 @@ func (gui *Gui) handleNewBranchOffCurrentItem() error {
 		title:          message,
 		initialContent: prefilledName,
 		handleConfirm: func(response string) error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.CreateBranch).NewBranch(sanitizedBranchName(response), item.ID()); err != nil {
+			gui.logAction(gui.Tr.Actions.CreateBranch)
+			if err := gui.Git.Branch.New(sanitizedBranchName(response), item.ID()); err != nil {
 				return err
 			}

--- a/pkg/gui/cherry_picking.go
+++ b/pkg/gui/cherry_picking.go
@@ -148,7 +148,8 @@ func (gui *Gui) HandlePasteCommits() error {
 		prompt: gui.Tr.SureCherryPick,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.CherryPickingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.CherryPick).CherryPickCommits(gui.State.Modes.CherryPicking.CherryPickedCommits)
+				gui.logAction(gui.Tr.Actions.CherryPick)
+				err := gui.Git.Rebase.CherryPickCommits(gui.State.Modes.CherryPicking.CherryPickedCommits)
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
--- a/pkg/gui/command_log_panel.go
+++ b/pkg/gui/command_log_panel.go
@@ -6,36 +6,48 @@ import (
 	"strings"
 	"time"

-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/constants"
 	"github.com/jesseduffield/lazygit/pkg/gui/style"
 	"github.com/jesseduffield/lazygit/pkg/theme"
 )

-func (gui *Gui) GetOnRunCommand() func(entry oscommands.CmdLogEntry) {
-	// closing over this so that nobody else can modify it
-	currentSpan := ""
-
-	return func(entry oscommands.CmdLogEntry) {
-		if gui.Views.Extras == nil {
-			return
-		}
-
-		gui.Views.Extras.Autoscroll = true
-
-		if entry.GetSpan() != currentSpan {
-			fmt.Fprint(gui.Views.Extras, "\n"+style.FgYellow.Sprint(entry.GetSpan()))
-			currentSpan = entry.GetSpan()
-		}
-
-		textStyle := theme.DefaultTextColor
-		if !entry.GetCommandLine() {
-			textStyle = style.FgMagenta
-		}
-		gui.CmdLog = append(gui.CmdLog, entry.GetCmdStr())
-		indentedCmdStr := "  " + strings.Replace(entry.GetCmdStr(), "\n", "\n  ", -1)
-		fmt.Fprint(gui.Views.Extras, "\n"+textStyle.Sprint(indentedCmdStr))
+// our UI command log looks like this:
+// Stage File
+//   git add -- 'filename'
+// Unstage File
+//   git reset HEAD 'filename'
+//
+// The 'Stage File' and 'Unstage File' lines are actions i.e they group up a set
+// of command logs (typically there's only one command under an action but there may be more).
+// So we call logAction to log the 'Stage File' part and then we call logCommand to log the command itself.
+// We pass logCommand to our OSCommand struct so that it can handle logging commands
+// for us.
+func (gui *Gui) logAction(action string) {
+	if gui.Views.Extras == nil {
+		return
 	}
+
+	gui.Views.Extras.Autoscroll = true
+
+	fmt.Fprint(gui.Views.Extras, "\n"+style.FgYellow.Sprint(action))
+}
+
+func (gui *Gui) logCommand(cmdStr string, commandLine bool) {
+	if gui.Views.Extras == nil {
+		return
+	}
+
+	gui.Views.Extras.Autoscroll = true
+
+	textStyle := theme.DefaultTextColor
+	if !commandLine {
+		// if we're not dealing with a direct command that could be run on the command line,
+		// we style it differently to communicate that
+		textStyle = style.FgMagenta
+	}
+	gui.CmdLog = append(gui.CmdLog, cmdStr)
+	indentedCmdStr := "  " + strings.Replace(cmdStr, "\n", "\n  ", -1)
+	fmt.Fprint(gui.Views.Extras, "\n"+textStyle.Sprint(indentedCmdStr))
 }

 func (gui *Gui) printCommandLogHeader() {
--- a/pkg/gui/commit_files_panel.go
+++ b/pkg/gui/commit_files_panel.go
@@ -45,7 +45,7 @@ func (gui *Gui) commitFilesRenderToMain() error {
 	to := gui.State.CommitFileManager.GetParent()
 	from, reverse := gui.getFromAndReverseArgsForDiff(to)

-	cmdObj := gui.GitCommand.ShowFileDiffCmdObj(from, to, reverse, node.GetPath(), false)
+	cmdObj := gui.Git.WorkingTree.ShowFileDiffCmdObj(from, to, reverse, node.GetPath(), false)
 	task := NewRunPtyTask(cmdObj.GetCmd())

 	return gui.refreshMainViews(refreshMainOpts{
@@ -63,7 +63,8 @@ func (gui *Gui) handleCheckoutCommitFile() error {
 		return nil
 	}

-	if err := gui.GitCommand.WithSpan(gui.Tr.Spans.CheckoutFile).CheckoutFile(gui.State.CommitFileManager.GetParent(), node.GetPath()); err != nil {
+	gui.logAction(gui.Tr.Actions.CheckoutFile)
+	if err := gui.Git.WorkingTree.CheckoutFile(gui.State.CommitFileManager.GetParent(), node.GetPath()); err != nil {
 		return gui.surfaceError(err)
 	}

@@ -82,7 +83,8 @@ func (gui *Gui) handleDiscardOldFileChange() error {
 		prompt: gui.Tr.DiscardFileChangesPrompt,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.RebasingStatus, func() error {
-				if err := gui.GitCommand.WithSpan(gui.Tr.Spans.DiscardOldFileChange).DiscardOldFileChanges(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, fileName); err != nil {
+				gui.logAction(gui.Tr.Actions.DiscardOldFileChange)
+				if err := gui.Git.Rebase.DiscardOldFileChanges(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, fileName); err != nil {
 					if err := gui.handleGenericMergeCommandResult(err); err != nil {
 						return err
 					}
@@ -105,7 +107,7 @@ func (gui *Gui) refreshCommitFilesView() error {
 	to := gui.State.Panels.CommitFiles.refName
 	from, reverse := gui.getFromAndReverseArgsForDiff(to)

-	files, err := gui.GitCommand.Loaders.CommitFiles.GetFilesInDiff(from, to, reverse)
+	files, err := gui.Git.Loaders.CommitFiles.GetFilesInDiff(from, to, reverse)
 	if err != nil {
 		return gui.surfaceError(err)
 	}
@@ -143,7 +145,7 @@ func (gui *Gui) handleToggleFileForPatch() error {
 	}

 	toggleTheFile := func() error {
-		if !gui.GitCommand.PatchManager.Active() {
+		if !gui.Git.Patch.PatchManager.Active() {
 			if err := gui.startPatchManager(); err != nil {
 				return err
 			}
@@ -152,14 +154,14 @@ func (gui *Gui) handleToggleFileForPatch() error {
 		// if there is any file that hasn't been fully added we'll fully add everything,
 		// otherwise we'll remove everything
 		adding := node.AnyFile(func(file *models.CommitFile) bool {
-			return gui.GitCommand.PatchManager.GetFileStatus(file.Name, gui.State.CommitFileManager.GetParent()) != patch.WHOLE
+			return gui.Git.Patch.PatchManager.GetFileStatus(file.Name, gui.State.CommitFileManager.GetParent()) != patch.WHOLE
 		})

 		err := node.ForEachFile(func(file *models.CommitFile) error {
 			if adding {
-				return gui.GitCommand.PatchManager.AddFileWhole(file.Name)
+				return gui.Git.Patch.PatchManager.AddFileWhole(file.Name)
 			} else {
-				return gui.GitCommand.PatchManager.RemoveFile(file.Name)
+				return gui.Git.Patch.PatchManager.RemoveFile(file.Name)
 			}
 		})

@@ -167,19 +169,19 @@ func (gui *Gui) handleToggleFileForPatch() error {
 			return gui.surfaceError(err)
 		}

-		if gui.GitCommand.PatchManager.IsEmpty() {
-			gui.GitCommand.PatchManager.Reset()
+		if gui.Git.Patch.PatchManager.IsEmpty() {
+			gui.Git.Patch.PatchManager.Reset()
 		}

 		return gui.postRefreshUpdate(gui.State.Contexts.CommitFiles)
 	}

-	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != gui.State.CommitFileManager.GetParent() {
+	if gui.Git.Patch.PatchManager.Active() && gui.Git.Patch.PatchManager.To != gui.State.CommitFileManager.GetParent() {
 		return gui.ask(askOpts{
 			title:  gui.Tr.DiscardPatch,
 			prompt: gui.Tr.DiscardPatchConfirm,
 			handleConfirm: func() error {
-				gui.GitCommand.PatchManager.Reset()
+				gui.Git.Patch.PatchManager.Reset()
 				return toggleTheFile()
 			},
 		})
@@ -194,7 +196,7 @@ func (gui *Gui) startPatchManager() error {
 	to := gui.State.Panels.CommitFiles.refName
 	from, reverse := gui.getFromAndReverseArgsForDiff(to)

-	gui.GitCommand.PatchManager.Start(from, to, reverse, canRebase)
+	gui.Git.Patch.PatchManager.Start(from, to, reverse, canRebase)
 	return nil
 }

@@ -213,7 +215,7 @@ func (gui *Gui) enterCommitFile(opts OnFocusOpts) error {
 	}

 	enterTheFile := func() error {
-		if !gui.GitCommand.PatchManager.Active() {
+		if !gui.Git.Patch.PatchManager.Active() {
 			if err := gui.startPatchManager(); err != nil {
 				return err
 			}
@@ -222,18 +224,14 @@ func (gui *Gui) enterCommitFile(opts OnFocusOpts) error {
 		return gui.pushContext(gui.State.Contexts.PatchBuilding, opts)
 	}

-	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != gui.State.CommitFileManager.GetParent() {
+	if gui.Git.Patch.PatchManager.Active() && gui.Git.Patch.PatchManager.To != gui.State.CommitFileManager.GetParent() {
 		return gui.ask(askOpts{
-			title:               gui.Tr.DiscardPatch,
-			prompt:              gui.Tr.DiscardPatchConfirm,
-			handlersManageFocus: true,
+			title:  gui.Tr.DiscardPatch,
+			prompt: gui.Tr.DiscardPatchConfirm,
 			handleConfirm: func() error {
-				gui.GitCommand.PatchManager.Reset()
+				gui.Git.Patch.PatchManager.Reset()
 				return enterTheFile()
 			},
-			handleClose: func() error {
-				return gui.pushContext(gui.State.Contexts.CommitFiles)
-			},
 		})
 	}

--- a/pkg/gui/commit_message_panel.go
+++ b/pkg/gui/commit_message_panel.go
@@ -5,31 +5,23 @@ import (
 	"strings"

 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 func (gui *Gui) handleCommitConfirm() error {
 	message := strings.TrimSpace(gui.Views.CommitMessage.TextArea.GetContent())
+	gui.State.failedCommitMessage = message
 	if message == "" {
 		return gui.createErrorPanel(gui.Tr.CommitWithoutMessageErr)
 	}
-	flags := []string{}
-	skipHookPrefix := gui.UserConfig.Git.SkipHookPrefix
-	if skipHookPrefix != "" && strings.HasPrefix(message, skipHookPrefix) {
-		flags = append(flags, "--no-verify")
-	}

-	if gui.UserConfig.Git.Commit.SignOff {
-		flags = append(flags, "--signoff")
-	}
-
-	cmdObj := gui.GitCommand.CommitCmdObj(message, strings.Join(flags, " "))
-	gui.OnRunCommand(oscommands.NewCmdLogEntry(cmdObj.ToString(), gui.Tr.Spans.Commit, true))
+	cmdObj := gui.Git.Commit.CommitCmdObj(message)
+	gui.logAction(gui.Tr.Actions.Commit)

 	_ = gui.returnFromContext()
 	return gui.withGpgHandling(cmdObj, gui.Tr.CommittingStatus, func() error {
 		gui.Views.CommitMessage.ClearTextArea()
+		gui.State.failedCommitMessage = ""
 		return nil
 	})
 }
@@ -48,8 +40,7 @@ func (gui *Gui) handleCommitMessageFocused() error {
 		},
 	)

-	gui.renderString(gui.Views.Options, message)
-	return nil
+	return gui.renderString(gui.Views.Options, message)
 }

 func (gui *Gui) getBufferLength(view *gocui.View) string {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jesse Duffield	ae98797bca	do not show branch graph when in filtering mode	2022-01-17 19:24:10 +11:00
Jesse Duffield	595aca2a4b	make integration test pass	2022-01-17 19:14:59 +11:00
Jesse Duffield	2691477aff	allow sandbox mode with integration tests	2022-01-17 19:14:59 +11:00
Jesse Duffield	8ca71eeb36	add git bisect run script	2022-01-17 19:14:59 +11:00
Jesse Duffield	d3a3c8d87d	add integration test for merge conflicts resolved externally	2022-01-17 19:14:59 +11:00
Jesse Duffield	ee622d044e	add integration test for staging view	2022-01-17 19:14:59 +11:00
Jesse Duffield	99035959a1	fix merge scroll bug	2022-01-16 23:16:05 +11:00
Jesse Duffield	0092c9d08d	fix bug with subprocess	2022-01-16 03:32:09 +00:00
Jesse Duffield	befa35645e	fix bug which prevented quitting with confirm	2022-01-15 20:35:25 +11:00
Jesse Duffield	7a690f9078	appease CI	2022-01-15 15:34:01 +11:00
Jesse Duffield	dafac52a4c	see if this fixes CI linting	2022-01-15 15:34:01 +11:00
Jesse Duffield	1c84f77319	always specify upstream when pushing/pulling	2022-01-15 15:34:01 +11:00
Jesse Duffield	8d8bdb948b	avoid deadlock in merge panel	2022-01-15 14:15:41 +11:00
Jesse Duffield	cdcfeb396f	stop refreshing the screen so much	2022-01-15 14:15:41 +11:00
Jesse Duffield	f5b9ad8c00	add complex custom command integration test	2022-01-15 10:14:19 +11:00
Jesse Duffield	8263d15b03	fix issue where custom command would not open a menu	2022-01-15 10:14:19 +11:00
TicClick	4744b39f03	work with absolute paths when invoked with --path	2022-01-09 14:35:57 +11:00
Jesse Duffield	2436ff197a	fewer panics	2022-01-09 14:14:47 +11:00
Jesse Duffield	3b30b9bba2	add integration test for rewording old commit	2022-01-09 14:14:47 +11:00
Jesse Duffield	e5096e71ab	add integration test for discarding old files	2022-01-09 14:14:47 +11:00
Jesse Duffield	ceb927fec0	fix formatting	2022-01-09 14:14:47 +11:00
Jesse Duffield	0dfd02c42d	allow rewording old commits	2022-01-09 14:14:47 +11:00
Jesse Duffield	ee15202207	add newline after message because it looks like the message doesn't appear otherwise for some reason	2022-01-09 14:09:53 +11:00
Jesse Duffield	a936c0592f	more refactoring	2022-01-09 14:09:53 +11:00
Jesse Duffield	06687c8a59	add integration test for entering credentials	2022-01-09 14:09:53 +11:00
Jesse Duffield	4d80c87736	use a string builder for credential checking	2022-01-09 14:09:53 +11:00
Jesse Duffield	267ecbe694	refactor code for handling credential requests	2022-01-09 14:09:53 +11:00
Jesse Duffield	ccf90466fa	fix test	2022-01-09 14:09:53 +11:00
Jesse Duffield	16c9b5404d	restore field	2022-01-09 14:09:53 +11:00
Jesse Duffield	18f48a43d5	add some more linters	2022-01-09 14:09:53 +11:00
Jesse Duffield	5d6d894286	fix test	2022-01-09 14:09:53 +11:00
Jesse Duffield	e4e521f58a	pass repo to struct	2022-01-09 14:09:53 +11:00
Jesse Duffield	fdf79fdeee	fix bug that caused credentials popup to be raised unexpectedly	2022-01-09 14:09:53 +11:00
Jesse Duffield	0dd1c12e2f	fix format issue	2022-01-09 14:09:53 +11:00
Jesse Duffield	364c5db19c	shorten name	2022-01-09 14:09:53 +11:00
Jesse Duffield	c9a0cc6b30	refactor	2022-01-09 14:09:53 +11:00
Jesse Duffield	3621854dc7	fix tests	2022-01-09 14:09:53 +11:00
Jesse Duffield	c6b57d9b57	WIP	2022-01-09 14:09:53 +11:00
Jesse Duffield	a7a61cdc83	rearrange	2022-01-09 14:09:53 +11:00
Jesse Duffield	ee8ff6512f	trim down gitcommand struct some more	2022-01-09 14:09:53 +11:00
Jesse Duffield	e8229f0ee0	support general git config calls	2022-01-09 14:09:53 +11:00
Jesse Duffield	610e503296	refactor git flow	2022-01-09 14:09:53 +11:00
Jesse Duffield	e92076d2c2	start removing direct calls to cmd.New from gui	2022-01-09 14:09:53 +11:00
Jesse Duffield	d9089098c3	remove field	2022-01-09 14:09:53 +11:00
Jesse Duffield	3f44eac95b	remove repo field	2022-01-09 14:09:53 +11:00
Jesse Duffield	946a35b59d	remove OSCommand field	2022-01-09 14:09:53 +11:00
Jesse Duffield	007235df23	refactor	2022-01-09 14:09:53 +11:00
Jesse Duffield	f503ff1ecb	start breaking up git struct	2022-01-09 14:09:53 +11:00
Jesse Duffield	4a1d23dc27	bump gocui	2022-01-08 16:05:11 +11:00
Pieter van Loon	7539929703	use bright colors for highlighting	2022-01-08 16:05:11 +11:00
Jesse Duffield	48a4565d1f	remove log of error now that we're returning it normally	2022-01-07 11:01:42 +11:00
Jakob Kogler	673c4a1296	also test for empty prefill after successful commit	2022-01-07 11:01:42 +11:00
Jakob Kogler	ee7a6391a8	remove redundant commit	2022-01-07 11:01:42 +11:00
Jakob Kogler	68fc6059d3	rename variable to failedCommitMessage	2022-01-07 11:01:42 +11:00
Jakob Kogler	d517531c16	test remembering the commit message for a failing commit	2022-01-07 11:01:42 +11:00
Jakob Kogler	f981255a5b	don't ignore error when commit with subprocess fails If signing by GPG is enabled, the git commit command will be executed in a subprocess, differently from when it is executed without GPG signing. In case of an error, e.g. a failing pre-commit hook, the error needs to be passed along, and not just ignored.	2022-01-07 11:01:42 +11:00
Jakob Kogler	beedc2553d	remember the message if commit fails In case a commit fails, e.g. because a pre-commit hook returns an error, lazygit will now remember the commit message and will suggest it during the next commit (e.g. after fixing the error of the pre-commit hook).	2022-01-07 11:01:42 +11:00
Jesse Duffield	0d3e5e6a1d	simplify fetch	2022-01-07 10:52:51 +11:00
Jesse Duffield	93729ba61b	fix some things	2022-01-07 10:52:51 +11:00
Jesse Duffield	91fe68576c	refactor	2022-01-07 10:52:51 +11:00
Jesse Duffield	bbb5eee23a	privatise some fields	2022-01-07 10:52:51 +11:00
Jesse Duffield	05fa483f48	simplify how we log commands	2022-01-07 10:52:51 +11:00
Jesse Duffield	e524e39842	move lint into ci yaml	2022-01-04 11:12:04 +11:00
Jesse Duffield	e8a1a4ffc0	add cheatsheet check script	2022-01-04 11:12:04 +11:00
Jesse Duffield	8e66d2761e	make it clear that keybinding cheat sheets are auto-generated	2022-01-04 09:33:35 +11:00
Jesse Duffield	95b2e9540a	update tests	2022-01-04 09:07:15 +11:00
Jesse Duffield	3911575041	appease golangci-lint	2022-01-04 09:07:15 +11:00
Jesse Duffield	efa743b52e	small change	2022-01-04 09:07:15 +11:00
Jesse Duffield	6da6c1f2f2	small copy changes	2022-01-04 09:07:15 +11:00
Jesse Duffield	c82606a92a	fix broken format call	2022-01-04 09:07:15 +11:00
Jesse Duffield	194ff1630c	do dependency injection up front and in one place	2022-01-04 09:07:15 +11:00
Jesse Duffield	2cb8aff940	no more mocking command	2022-01-04 09:07:15 +11:00
Jesse Duffield	25195eacee	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	ad9b2df104	more test refactoring	2022-01-04 09:07:15 +11:00
Jesse Duffield	9c4a819683	refactor sync test	2022-01-04 09:07:15 +11:00
Jesse Duffield	38bc48312e	refactor files_test.go	2022-01-04 09:07:15 +11:00
Jesse Duffield	547e0153ec	stash and tags loaders	2022-01-04 09:07:15 +11:00
Jesse Duffield	44b6d26b10	move remotes loader into loaders package	2022-01-04 09:07:15 +11:00
Jesse Duffield	d69ce7a529	move reflog commit loader into loaders package	2022-01-04 09:07:15 +11:00
Jesse Duffield	9b2b0fc122	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	96c2887fd0	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	66e840bc3f	more refactoring	2022-01-04 09:07:15 +11:00
Jesse Duffield	5b35724243	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	b028f37ba8	updating specs	2022-01-04 09:07:15 +11:00
Jesse Duffield	1fc0d786ae	better typing for rebase mode	2022-01-04 09:07:15 +11:00
Jesse Duffield	9d4ff6b465	fix logging	2022-01-04 09:07:15 +11:00
Jesse Duffield	95f4ceea34	refactor	2022-01-04 09:07:15 +11:00
Jesse Duffield	43a4fa970d	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	192a548c99	refactoring the config struct	2022-01-04 09:07:15 +11:00
Jesse Duffield	01ea5813a8	align Gui struct with GitCommand	2022-01-04 09:07:15 +11:00
Jesse Duffield	03b946cc8f	no more config in git command struct	2022-01-04 09:07:15 +11:00
Jesse Duffield	18ab086126	introduce Common struct for passing around common stuff	2022-01-04 09:07:15 +11:00
Jesse Duffield	b4c078d565	WIP	2022-01-04 09:07:15 +11:00
Jesse Duffield	157dd309f7	fix integration test	2022-01-03 15:26:53 +11:00